All articles Day 12 · Going further

Pick the right model.
Spend less. Run in parallel.

By Kowshik Kesavarapu 5 min quick start + 27 min full guide Oct 23, 2026

Beyond the roadmap: the dials you have not touched yet. Days 1 to 11 taught you what Claude Code can do. Today is about how much it does for how little: which model to pick, how hard it should think, what each session costs, and how to run several jobs side by side without them colliding. None of it is exotic. Most people simply never open these settings, and pay for it in slow answers, surprise limits and tangled branches.

01The big picture: four dials

What. Every Claude Code session is shaped by four dials. You have been using them on their default positions all along.

Dial 1: ModelWhich Claude does the work. A bigger model reasons better and costs more; a smaller one is faster and cheaper. Sections 02 to 05.
Dial 2: Effort and thinkingHow long the model reasons before it answers. More effort helps hard problems and wastes time and tokens on easy ones. Section 06.
Dial 3: ContextHow much text rides along with every message. This is the biggest driver of cost, and you steer it with Day 5 habits. Sections 07 to 11.
Dial 4: ParallelismHow many sessions run at once, each in its own copy of your code. Sections 12 to 16.

Why it matters. A one-line rename does not need your biggest model thinking at full effort. A tricky design decision does. Matching the dial to the job is the difference between an assistant that feels instant and cheap, and one that feels slow and burns through your plan limit by lunchtime.

02What a "model" is, and the aliases you can type

What. A model is the specific version of Claude doing the thinking. Anthropic ships a family: a fast small one (Haiku), a balanced everyday one (Sonnet), a stronger one for complex reasoning (Opus), and a top tier for the hardest, longest tasks (Fable). New versions arrive regularly, so Claude Code lets you type a short alias that always means "the latest of that kind" instead of a long version name.

sonnetLatest Sonnet. The daily-driver choice for writing and fixing code.
opusLatest Opus. For complex reasoning: architecture, tricky bugs, big refactors.
haikuLatest Haiku. Fast and cheap, for simple, mechanical jobs.
fable and bestfable is the top tier where your account has it. best means "the strongest I can use": Fable where available, otherwise Opus.
opusplanA hybrid: Opus while you are in plan mode, Sonnet when it starts executing. Section 04.
sonnet[1m] and opus[1m]The same models with a one million token context window. Section 05.
defaultNot a model: it clears your override and goes back to what your account normally gets.

Why aliases. Because model names change. If you write sonnet in a script or setting, it keeps working when the next Sonnet appears. If you pin a full name you stay on that exact version, which is what you want only when you need identical behaviour over time.

03How to switch models: terminal and VS Code

What and why. You can set the model in several places. They stack, and the more specific one wins. Knowing the order saves you from "why is it still using Opus?" confusion.

>_PowerShell: four ways to pick a model
—☐✕
# 1. inside a running session (highest priority)
/model sonnet
/model              # no name: opens a picker

# 2. at startup
claude --model opus

# 3. an environment variable for this shell
$env:ANTHROPIC_MODEL = "sonnet"

# 4. a saved default in your settings file
#    ~/.claude/settings.json  →  { "model": "sonnet" }

How, step by step in the picker. Type /model and press Enter. Use the arrow keys to move between models. Press Enter to switch and save it as your default, or press s to switch for this session only. Use s when you are trying something for one task and do not want it to follow you around.

In VS Code. Click the model name at the bottom of the prompt box, or open the command menu with / and choose Switch model…. It is the same picker. When the model supports effort levels, the picker shows an Effort row and the model button shows your selected level. Typing /model works in the chat box too.

A note for scripts. In headless runs (Day 11) add --model sonnet to the claude -p command. Subagents (Day 9) can also carry their own model, so a reviewer can run on a cheaper model than your main session.

04Which model for which job

What. There is no single best model, only a best fit. Use this as a starting rule and adjust from experience.

Everyday coding: SonnetWriting a function, fixing a clear bug, adding tests, explaining code, small refactors. It handles most work well and costs less than Opus. This is a sensible default.
Hard thinking: Opus (or Fable)Designing a system, a bug you cannot localise, a migration across many files, reviewing a risky change. Reach for it when Sonnet goes in circles.
Simple and mechanical: HaikuRenaming, formatting, summarising a log, running a checklist. Great for subagents that do narrow work and for scripts that run often.
Plan hard, build cheap: opusplanPlan mode (Day 4) is where reasoning matters most and it uses few tokens, so Opus plans. Then Claude switches to Sonnet to write the code. You get strong plans without paying Opus rates for every edit. Set it with /model opusplan.

Why this works. Most of the tokens in a session go into reading files and writing edits, not into the one hard decision at the start. Put the expensive model on the decision and the cheap one on the typing. A good habit: start on Sonnet, and only switch up when you hit a wall, then switch back.

Subagents. Remember Day 9? A reviewer subagent can be pinned to a cheaper model with model: haiku in its frontmatter. Cheap model for the narrow chores, strong model for the conversation.

05Context window size, and the 1M option

What. The context window is how much text the model can hold in mind at once: your conversation, files it has read, tool output, your CLAUDE file. Think of it as the size of the desk. When the desk is full, Claude Code compacts: it summarises older material to free space (Day 5).

Why it matters. A bigger desk lets Claude work across a large codebase or a very long task without forgetting early details. But a bigger desk is not free: every message re-sends what is on it (section 08). More room is a tool for big jobs, not a reason to stop clearing.

How. Add [1m] to an alias, for example /model sonnet[1m] or /model opus[1m]. Some newer models already have a one million token window with no suffix, and the picker tells you what you have. To make compaction happen earlier than the maximum, set the window you want, for example /autocompact 200k (or the --autocompact flag). A smaller auto-compact window keeps long sessions leaner.

06Effort and thinking: how hard it reasons

What. Before answering, the model can "think": work through the problem in a hidden scratchpad. Effort is the dial for how much. The levels are low, medium, high, xhigh and max, and which ones exist depends on the model.

Why it matters. Thinking tokens are billed like output, and they take time. At high effort a simple question can pause for a long moment for no benefit. At low effort a tricky bug may get a shallow answer. Matching effort to difficulty is the cheapest speed-up you can make.

>_PowerShell: effort and thinking controls
—☐✕
# in a session
/effort             # opens a slider
/effort low         # set a level directly
/effort auto        # clear your saved level

# at startup
claude --effort high

# one hard turn: put this word anywhere in your prompt
# "ultrathink: why does the split lose a cent?"

# turn thinking on or off for this session: Alt+T
# read the thinking text: Ctrl+O (verbose mode)

How to use it. Low or medium for renames, formatting, quick questions, boilerplate. High for normal feature work and debugging. The top levels for the genuinely hard problem, and drop back afterwards. In the /model picker you can also move the effort slider with the left and right arrow keys. In VS Code use the Effort row in the model picker.

One honest caveat. On some of the newest models thinking is always on and cannot be switched off; you tune it with effort instead. If a setting such as MAX_THINKING_TOKENS seems to do nothing, that is why. The model picker shows what your model supports.

07How Claude Code is billed, in plain words

What. Everything Claude reads and writes is counted in tokens, roughly three quarters of a word each. On the API you pay per token. On a Pro, Max, Team or Enterprise plan the same tokens draw down your plan limit (a rolling five-hour window plus a weekly one), and you can add usage credits to keep going past it.

Why costs surprise people. You do not pay once for your question. Claude Code sends the whole conversation so far with every request, and each tool call is another request. So a one-line follow-up at the end of a long session carries everything above it. Keep two ideas apart. Context is what is sent in each request, and it fills the window whether or not it is cached. Prompt caching only changes the billing: repeated material at the start of the conversation is billed at a much cheaper rate, but it still counts toward the window. Compaction is what actually shrinks the context.

Long contextThe longer the conversation, the more every message weighs. This is the number one reason usage climbs.
Cache missesThe cache expires after a while. Come back from a long break and your first message re-processes the whole context at full price.
ThinkingHigh effort means more output tokens before the answer even starts.
HelpersEach subagent has its own context and its own requests. Scheduled loops and background sessions keep sending context even when you are away.
Compaction/compact has to read the whole conversation to summarise it, so compacting a huge session is itself a big request. /clear is free.

08See what you are spending

What and why. You cannot manage what you cannot see. Claude Code has three views, from a quick glance to a deep look.

>_PowerShell: the three views
—☐✕
/usage      # session totals: tokens, estimated cost, per model; plan limits on subscriptions
/context    # what is filling the context window right now
/insights   # a report on how you work: friction points, suggestions

/usage. At the top is the Session block: total tokens per model and an estimated dollar figure computed from list prices. Treat the dollars as an estimate; the Claude Console is the authority for API billing. If you are on a subscription it also shows plan usage bars and a breakdown of which skills, subagents, plugins and MCP servers used the most, with recommendations. Press d or w to flip between the last 24 hours and the last 7 days. It also shows a Prompt cache line, so you can see how much of your input came from cache.

/context. A picture of what is on the desk: your CLAUDE file, MCP tool names, skills, conversation. If one thing is surprisingly large, that is your first cleanup target.

In VS Code. Run /usage in the chat box to open the Account & usage dialog, with a Day and Week toggle. A small clock icon beside the context indicator estimates how long your prompt cache has left before it expires, which tells you whether the next message will be cheap or expensive.

Always visible. You can show context use and cost in your status line (the bar at the bottom of the terminal) by configuring it in settings, so the numbers are in view all day.

09Ten habits that cut tokens without cutting quality

What. None of these reduce what Claude can do. They only stop you paying to carry things you no longer need. Each pairs a habit with the reason.

1. Clear between unrelated tasks/clear starts fresh. Old context taxes every later message. Use /rename first so you can find the old session again with /resume.
2. Compact with instructions/compact Focus on the failing tests and the files we changed keeps what matters. You can also add a "Compact instructions" section to your CLAUDE file.
3. Be specific"Add input validation to the login function in auth.py" reads one file. "Improve the codebase" triggers a broad hunt.
4. Plan firstPlan mode (Shift+Tab) catches a wrong direction before it costs a pile of edits (Day 4).
5. Stop and rewind earlyPress Esc when it heads the wrong way. /rewind or double Esc restores the conversation and code to a checkpoint. In VS Code hover a message and use the rewind button.
6. Keep the CLAUDE file leanIt loads every session. Aim for under about 200 lines; move rarely-needed procedures into skills (Day 8), which load only when used.
7. Trim MCP serversRun /mcp and disable servers you are not using. Where a plain command exists (gh, aws), the command costs less context than a server.
8. Push noisy work into subagentsTest runs and log digging stay in the helper's context; only the summary comes back (Day 9).
9. Filter with hooksA hook can grep a 10,000-line log down to the error lines before Claude sees it (Day 9).
10. Give a way to checkName the test command or the expected output. Claude then verifies its own work instead of you asking for a fix round.

10Why a session you left open all day gets expensive

What. Two quiet effects. First, the cache has a limited lifetime, so the first message after a long break is billed as if it were a brand new, full-size request. Second, anything that keeps firing while you are away (a scheduled /loop, background work, messages from other sessions) keeps re-sending the whole context.

How to act on it. Before lunch or an overnight break, either /clear (if the task is done), or write down where you are and /clear, then pick up fresh. Resuming a named session with claude --resume restores the conversation, so you can still continue. Stop loops you no longer need. If you want continuity and a small context, /compact before you leave rather than after you return.

11Limits and safety nets

What. Three kinds of ceiling exist. Knowing which one you hit tells you what to do.

A plan limit"You've hit your session limit" on a subscription. It is shared across models, so switching with /model will not fix it. Options: wait for the reset time it shows, or turn on usage credits with /usage-credits.
A spend limitSet on usage credits (by you, or by your organisation). Raise it in your settings, or wait for the reset.
A budget you set yourselfFor unattended jobs, claude -p ... --max-budget-usd 2 stops a run at a dollar figure, and --max-turns caps the number of steps (Day 11).

A model-specific message such as "You've hit your Opus limit" is different: switching to another family with /model keeps you working.

12Parallel work, part one: resume and continue

What. Before running things side by side, learn to pick up one thing later. Claude Code saves every conversation on your machine.

>_PowerShell: coming back to work
—☐✕
claude --continue        # the most recent session in this folder
claude --resume          # pick from a list
/resume                  # the same list, from inside a session
/rename billsplitter-api # give this session a findable name
claude --from-pr 12      # sessions linked to pull request 12

Why. Re-explaining a task costs more than resuming it, and a named session is easy to find a week later. Claude Code links a session to a pull request when it creates one, so --from-pr brings back exactly the conversation behind that PR. In VS Code, the past conversations list in the panel does the same job; click one to resume it.

13Parallel work, part two: git worktrees

What. A git worktree is a second folder with its own copy of your files on its own branch, sharing the same repository history. Normally one folder holds one branch at a time. With worktrees, you can have main in one folder, feature-auth in another and a bug fix in a third, all at once.

Why it matters. Two Claude sessions editing the same folder step on each other: one changes a file while the other is mid-thought, and branches get mixed. Give each session its own worktree and they cannot collide. You can start a long refactor in one terminal, and keep fixing a small bug in another.

>_PowerShell: two isolated sessions
—☐✕
# terminal 1
claude --worktree feature-auth

# terminal 2 (a different name = a different, isolated copy)
claude -w fix-rounding

# no name? Claude invents one, like bright-running-fox
claude --worktree

What happens. Claude creates the folder under .claude/worktrees/<name>/ in your repository and checks out a new branch called worktree-<name>, then starts the session in it. Requirements: the folder must be a git repository with at least one commit, and you should have run claude there once to accept the trust prompt.

Three tidy-up steps.

1. Ignore the folderAdd .claude/worktrees/ to your .gitignore so worktree contents do not show up as untracked files in your main checkout.
2. Bring your secrets alongA worktree is a fresh checkout, so a gitignored .env file is missing. List such files in a .worktreeinclude file at the project root (same syntax as .gitignore) and Claude copies them into every new worktree.
3. Install dependenciesEach worktree needs its own npm install or equivalent. Ask Claude to do it as the first prompt.

14Finishing and cleaning up worktrees

What. When you exit a worktree session, Claude checks whether anything would be lost. If the worktree is clean and the session was unnamed, it is removed automatically. If there is work in it, you get a choice: keep (folder and branch stay) or remove (both are deleted, work included). Read the prompt before you answer.

How to continue later. Claude prints a ready-made command such as claude --worktree feature-auth --resume. Then the normal flow from Day 6 applies: commit on that branch, push, open a pull request, merge, and remove the worktree.

>_PowerShell: managing worktrees yourself
—☐✕
git worktree list                          # what exists
git worktree add ..\proj-hotfix -b hotfix  # make one by hand, on a new branch
git worktree remove ..\proj-hotfix         # delete one you finished with
claude --worktree "#1234"                  # branch from pull request 1234

Good to know. Claude's permission approvals saved from a worktree apply back to the main checkout. Plugins installed at project scope (Day 10) load in worktrees too. And inside a worktree session, Claude Code blocks edits that would reach into the main checkout, so one session cannot quietly modify another's files.

15Parallel work in VS Code, and with subagents

VS Code. Open another conversation with Open in New Tab or Open in New Window from the Command Palette (Ctrl+Shift+P, type "Claude Code"), or press Ctrl+Shift+Esc. Each conversation keeps its own history and context. A small coloured dot on the spark icon shows status: blue means a permission request is waiting, orange means Claude finished while the tab was hidden. Keep your main session in the sidebar and open side tasks as tabs. To give a VS Code session its own worktree, start it with claude --worktree in the integrated terminal.

Subagents. Day 9 subagents split work inside one session. They can also run in their own worktrees so parallel edits do not clash: say "use worktrees for your agents", or put isolation: worktree in a custom subagent's frontmatter. A worktree with no changes is removed when the subagent finishes.

One session, several stepsPlain chat. Simple, cheapest. Use for most work.
One session, helpersSubagents. Keep verbose work out of your context.
Several sessions, same repoWorktrees. Separate branches and files, you drive each one.
Helpers that edit in parallelSubagents with isolation: worktree.

16Parallel costs more: use it with a plan

What. Three sessions running at once use roughly three sessions' worth of tokens, and each has its own context. Parallel work saves your time, not your tokens.

How to keep it sane. Run at most two or three at once, since you must still read and review every result. Put the cheaper model on the routine one (claude -w docs --model haiku), keep prompts focused, and finish and close a worktree before starting another. If you cannot review three branches carefully, you are running too many.

17A real day, using all four dials

The bill splitter again. Here is how the project from the capstone might run with these dials set deliberately.

Morning: plan/model opusplan, plan mode on. Opus works out how to handle the leftover cent; execution switches to Sonnet.
Build: low effort/effort medium. Writing tests and small functions does not need deep reasoning.
Stuck: one hard turn"ultrathink: why does 110.00 over 3 lose a cent in the percent mode?" Then back to medium.
Side task: worktreeIn a second terminal, claude -w docs --model haiku writes the README while the first session continues.
Before lunch/usage to check, /rename then /clear. After lunch, /resume the named session if needed.
End of day/insights to see where the friction was, and tune tomorrow's defaults.

18Which dial for which problem

"It is slow."Lower effort, or a smaller model. Check /context for a bloated window.
"It keeps getting it wrong."Raise effort, or switch to Opus for this task. Give it a test to check against.
"I hit my limit early."/usage to see who used it. Clear old sessions, trim MCP servers, use Sonnet.
"I forgot what we decided."/resume a named session, or write decisions in your CLAUDE file.
"Two jobs keep clashing."Worktrees, one per job.
"My bill is a surprise."Add --max-budget-usd to scripts, show cost in the status line, and review /usage weekly.

19When something goes wrong

The model I typed is not offeredYour plan or provider may not include it. Open /model to see the list, or check /status for your account.
Settings seem ignoredA flag beats an environment variable, which beats a settings file. Run /model to see what is active.
--worktree exits with a trust errorRun claude once in the folder and accept the trust prompt, then retry.
"Failed to resolve base branch HEAD"The repository has no commits yet. Make an initial commit first.
.env is missing in the worktreeAdd it to .worktreeinclude, or copy it by hand.
Cannot remove a worktreegit worktree remove --force <path> if it has changes you do not need; git worktree unlock first if git says it is locked.
Estimated cost looks offThe dollar figure is computed at list price. Check the Claude Console usage page for real API billing.

20Cheat sheet

>_PowerShell: everything on one screen
—☐✕
# model
/model sonnet | opus | haiku | opusplan | sonnet[1m]
claude --model sonnet

# effort and thinking
/effort low | medium | high | xhigh | max | auto
claude --effort high      # Alt+T toggles thinking, "ultrathink" for one turn

# see and shrink spend
/usage   /context   /insights
/clear   /compact Focus on ...   /rename name   /resume
/rewind  (or Esc Esc)

# limits
/usage-credits
claude -p "..." --max-budget-usd 2 --max-turns 10

# parallel
claude --continue | --resume | --from-pr 12
claude --worktree name   # or -w name
git worktree list | remove

21Questions beginners ask

Should I always use the biggest model?No. It is slower and costs more, and for routine work Sonnet is usually as good. Use the strong model for the hard parts.
Does switching model lose my conversation?No. The conversation continues; the next reply comes from the new model.
Is /usage the same as my bill?No. On the API it is an estimate at list price. On a subscription, plan usage matters more than dollars.
Do worktrees copy my whole project?They check out your tracked files again but share the git history, so they are light. Dependencies and ignored files are not copied unless you set .worktreeinclude or install them.
Can I run Claude in a worktree without git?Not by default. Other version control systems need creation and cleanup hooks.
How many sessions at once?As many as you can review carefully. Two or three is plenty for most people.
Is turning thinking off a good idea?Usually lower the effort instead. On the newest models thinking cannot be turned off at all.

22Try this today

1. Read your own numbers (5 min)Run /usage and /context in your biggest session. Note which model, how many tokens, and what fills the window.
2. Pick a default (5 min)Open /model, choose Sonnet and press Enter to save it. Keep Opus for the hard task of the week.
3. Try opusplan (15 min)Plan a small feature with /model opusplan and compare the result with your usual flow.
4. Two worktrees (20 min)In a repo with a commit, run claude -w one and claude -w two in two terminals, make a small change in each, then exit and look at git worktree list.
5. Run /insights (5 min)Read the report and change one habit this week.

Follow along

A new article lands every day. I post the short version on LinkedIn.