The Claude Code Settings Anthropic Engineers Use (and You Don’t)

TL;DR

Claude Code ships with many settings that most people never touch. Turning on a few of them gives you a setup that knows how you work, starts lighter, asks fewer questions and burns less of your usage. Almost all of them are free. Only the eval tools cost API money.

flowchart LR
    A[Default Claude Code] --> B[Set up smarter]
    B --> C[Keep it clean]
    C --> D[Fewer interruptions]
    D --> E[Lighter startup]
    E --> F[Faster daily work]
    F --> G[Your tuned setup]flowchart LR
    A[Default Claude Code] --> B[Set up smarter]
    B --> C[Keep it clean]
    C --> D[Fewer interruptions]
    D --> E[Lighter startup]
    E --> F[Faster daily work]
    F --> G[Your tuned setup]

1. Start with a smarter init

The normal /init scans your repo and writes a CLAUDE.md. The newer init flow does something better: it asks how you work first, makes a plan, and then creates your CLAUDE.md, skills and hooks to match

flowchart LR
    Q[Asks about your workflow] --> P[Makes a plan]
    P --> M[CLAUDE.md]
    P --> S[Skills]
    P --> H[Hooks]

# Turn on the new init experience
export CLAUDE_CODE_NEW_INIT=1
claude
> /init

Coming from Cursor or Codex? An import command brings over your instruction files and MCP servers, so you don’t rebuild everything by hand.

2. Keep your setup clean

Instructions written for older models often stop helping newer ones. Two tools help you tidy up:

• Prompt audit checks every instruction file and skill for outdated prompt-engineering habits. Run it whenever a new model comes out.
• Skill doctor shows how often each skill is used and how many tokens it costs. The skills list can also be sorted by token cost, so you can cut the heavy ones you never use.

flowchart TD
    N[New model released] --> A[Run prompt audit]
    A --> F[Fix outdated instructions]
    F --> D[Run skill doctor]
    D --> T{Skill heavy and unused?}
    T -- Yes --> R[Remove or trim]
    T -- No --> K[Keep]

3. Fewer interruptions on long tasks

Permission prompts break your flow. Auto mode setup learns which commands you usually allow, and you can add safe, read-only commands to an allow list.

flowchart LR
    C[Claude wants to run a command] --> L{On allow list?}
    L -- Yes --> R[Runs straight away]
    L -- No --> P[Asks you first]

{
  "permissions": {
    "allow": [
      "Bash(git status)",
      "Bash(git diff:*)",
      "Bash(ls:*)",
      "Bash(npm test:*)"
    ]
  }
}

Keep the allow list to read-only or easily reversible commands. Never allow-list anything that deletes, pushes or deploys.

4. A lighter startup

Every connector (Notion, Slack and so on) and built-in tool you load takes context space before you even type. Two easy wins:

• Stop the Claude app’s connectors from loading into every Claude Code session.
• Turn off artifacts if you don’t use them.

Both go into one settings file, and you can simply ask Claude to make the change for you.

flowchart LR
    subgraph Before
      B1[Connectors] --> CTX1[Context window]
      B2[Artifacts tool] --> CTX1
      B3[Your task] --> CTX1
    end
    subgraph After
      A3[Your task] --> CTX2[Context window]
    end

5. Testing apps that use AI

If your app calls an LLM, “it looked fine once” is not a test. Two commands help:

• Build eval writes a fixed set of tests for your AI feature.
• Hillclimb keeps changing your app and only keeps changes that score higher on those evals.

⚠️ Both call the API on every run, so they cost real money. Everything else in this post is free.

flowchart TD
    E[Build eval: fixed test set] --> S[Score current app]
    S --> C[Try a change]
    C --> R[Re-score]
    R --> B{Better score?}
    B -- Yes --> K[Keep change]
    B -- No --> U[Undo change]
    K --> C
    U --> C

6. While you’re working

• Clear context when accepting a plan. Start the build with a clean slate instead of a cluttered planning chat.
• Save plans in your project folder so teammates can read and review them.
• Output styles. Switch between five styles, from concise to learning mode.
• Thinking summaries. Bring them back with Ctrl+O.
• Focus mode shows only your prompt, Claude’s answer and a short summary.

flowchart LR
    P[Plan mode] --> A[Accept plan]
    A --> S[Plan saved to project folder]
    A --> C[Context cleared]
    C --> B[Build with fresh context]

7. Running more than one session

Three ways to split work, plus sessions that can talk to each other:

Sessions messaging each other is handy when one project spans several sessions. For example, a backend session can tell the frontend session that an API changed.

flowchart TD
    M[Main session] -->|branch| B[Copy: alternative idea]
    M -->|fork| F[Background side task]
    M -->|subtask| S[Subagent with full chat]
    B <-->|messages| M
    F <-->|messages| M

8. When you walk away

• Ask-user-question timeout. If Claude asks you something and you’re away, it picks the suggested answer and keeps going.
• Local notifications ping you when a session finishes or needs you.

sequenceDiagram
    participant C as Claude
    participant Y as You (away)
    C->>Y: Question with a suggested answer
    Note over C,Y: Timeout passes, no reply
    C->>C: Uses suggested answer
    C-->>Y: Notification: task done

9. Save your usage

The biggest saver is to plan with Opus and build with Sonnet. Planning needs the strongest reasoning; writing the code usually doesn’t. You can also set one model for all subagents. This matters most on the Pro plan, where limits arrive faster.

flowchart LR
    T[Your task] --> P[Planning: Opus]
    P --> B[Building: Sonnet]
    B --> SA[Subagents: one chosen model]

# Inside Claude Code
> /model opusplan

# Pick one model for every subagent
export CLAUDE_CODE_SUBAGENT_MODEL=sonnet

10. Shortcuts worth memorising

If you want to learn as you go, the powerup command gives short interactive lessons right inside Claude Code.

Putting it together

Most of these live in settings.json inside your .claude folder. Here’s a starter version (keys are illustrative, so check the docs for your version):

{
  "model": "opusplan",
  "outputStyle": "concise",
  "permissions": {
    "allow": ["Bash(git status)", "Bash(git diff:*)", "Bash(ls:*)"]
  },
  "env": {
    "CLAUDE_CODE_SUBAGENT_MODEL": "sonnet"
  }
}

The easiest path: open Claude Code and say “Add these settings to my settings.json”. It will edit the file for you.

flowchart LR
    Y[You] -->|ask| C[Claude Code]
    C -->|edits| S[.claude/settings.json]
    S --> N[Every new session uses it]

Key takeaway

The best Claude Code setup is one that knows how you work. A guided init, a clean set of skills, a sensible allow list and smart model routing get you most of the way, for free.

Source: AI LABS: You Need To Add This In Your Claude Code Setup Right Now