How to Get the Most Out of a $20 Claude Plan as a Developer

The $20 Claude plan is Pro, and it includes Claude Code. Claude Code on Pro now defaults to Opus 5.5 at medium effort, and with the September 22 launch Anthropic said it is raising five-hour limits on the same plans.

You get the most out of it by spending fewer tokens per task, not by using Claude less. That means one clear message instead of five, a fresh context between tasks, the right model and effort for the job, and no cold-cache surprises after a break.

One thing up front. I started on Pro, brand new to Claude Code, and I’m on the $200 Max plan now. The prices and limits below come from Anthropic’s pages, and my usage numbers come from Max.

Every factual claim about Anthropic’s plans and tools links to the page it came from, and I checked those pages on September 23, 2026. Sonnet 5.5 and Haiku 5.5 are due “in the coming weeks,” so parts of this will age. Anthropic doesn’t publish Pro token allowances, and I won’t invent one.

Here is the scorecard before the detail.

Habit	Why it helps on a $20 plan
Know where your config lives	Settings and `CLAUDE.md` files do nothing if they are in the wrong place.
One message: task, finish line, stop rule	Fewer turns, and every turn re-reads the whole conversation.
`/clear` between tasks	It costs nothing and drops stale context.
Start effort at `medium`, then experiment	You can’t turn thinking off on Opus 5.5. Effort is the dial.
`opusplan`	Opus 5.5 plans, Sonnet 5 types.
Skip Fable, fast mode and the advisor	Each one bills more or reads the transcript uncached.
Use ultracode for one job, not all day	It applies to every task in the session and fans out into many agents.
Mind the one-hour cache	The first message after a long break re-reads everything.

What does a $20 Claude plan give a developer?

Pro costs $20 a month, or $17 a month if you pay $200 up front, and it includes Claude Code. The plan also covers Claude Code inside VS Code, Cursor and JetBrains IDEs, per Anthropic’s Help Center.

Claude apps and Claude Code draw from one shared pool. Limits reset on a rolling five-hour session window, and there is a weekly limit that applies across all models. A long chat in the app and a long run in the terminal come out of the same tank.

The default model changed recently. The model docs say Pro now defaults to Opus 5.5, with medium as its default effort. Before Claude Code v2.1.280, Pro defaulted to Sonnet 5, so on an older version you may still see Sonnet.

The Opus 5.5 announcement adds one line: “we’re increasing five-hour usage limits on Pro, Max, Team, and seat-based Enterprise plans.” It gives no numbers.

Several blog posts quote “about 45 prompts” or “44,000 tokens” per window. I couldn’t find either in the Anthropic pages I read, which describe Pro only as “more usage” than Free. I’m leaving both out. Treat any exact Pro number as a guess unless it links to Anthropic.

What did I get wrong on my first Pro plan?

I started on Pro, and I was new to Claude Code. I didn’t know the tweaks or the ins and outs: the global config, the .claude folder, settings.json, CLAUDE.md. I wasn’t following Anthropic’s guidelines either, so I was barely able to use my $20 plan.

When I hit the limit, I couldn’t ask Claude anything else, so I reviewed the code it had generated by hand. Those were my early days of AI-assisted coding, and I took help from ChatGPT.

If that sounds familiar, here is the map I didn’t have. This is where Claude Code’s settings and memory files live:

~/.claude/settings.json is your user settings, for you in every project. Claude Code creates it the first time you change an option in /config that it stores there, such as the theme.
.claude/settings.json inside a repo is the shared project file, for everyone who clones it.
.claude/settings.local.json is your personal override for one project. Claude Code keeps it out of git when it creates the file. If you make it by hand, add it to .gitignore yourself.
~/.claude/CLAUDE.md holds your personal instructions for every project.
./CLAUDE.md or ./.claude/CLAUDE.md holds the project’s instructions, shared with your team through version control.

When the same key shows up in more than one settings file, the higher level wins. Project local beats shared project, and both beat your user settings.

Two traps I’d have avoided. First, CLAUDE.md is context, not enforcement. Claude treats it “as context, not enforced configuration,” so to block an action for certain, use a PreToolUse hook.

Second, keep it short. The size guidance says: “Longer files consume more context and reduce adherence.” Aim for under 200 lines, and run /context to see which memory files loaded.

The rest of this post is the guideline pass I skipped.

What actually eats your Claude plan limits?

Context, mostly. Claude Code sends your full conversation with every request. So “a one-line question in a session that has been open all day still draws usage for the whole conversation.”

Every tool call is another request carrying the same history. That is why one wandering session costs more than three short ones. I broke down the numbers in my Claude Code cost post, including why cache reads make the re-read cheap but not free.

Anthropic’s usage limit guide lists several other inputs, including:

Message length
Attached file size
Conversation length
Tool use
Model choice
Effort level

So the levers are what you send, how long the chat runs, and which model and effort reads it.

Then there is the cache clock. On a subscription, the main conversation’s cache lives for one hour while you are inside plan usage. Come back after a longer break and the first message reprocesses everything.

There are two catches. Subagents get a five-minute cache even on a subscription. And once you pass your limit and draw on usage credits, the main conversation drops to five minutes too.

Background work counts as well. A /loop or scheduled task fires on its interval even while you are away, and it sends your full context each time.

One more fact. You can’t turn thinking off on Opus 5.5, and thinking tokens are billed as output tokens.

So effort is the only dial you get. On a plan, /usage shows what your limits went to and flags long context or cache misses once one reaches 10 percent of recent use. Run it before you change anything.

You can also see the five-hour and weekly bars under Settings > Usage on claude.ai.

Should you change the effort level on Opus 5.5?

Start at medium, then play with it. In the model docs, medium “reduces token usage for cost-sensitive work that can trade off some intelligence,” and low is for “short, scoped, latency-sensitive tasks that are not intelligence-sensitive.”

Anthropic’s own Opus 5.5 playbook, written by Addy Osmani, has one useful data point. “One early tester said Opus 5.5 at its lowest effort caught more bugs than Opus 5 at high effort, with fewer false alarms.”

One tester is an anecdote, not a benchmark. It is still a fair reason to try low on scoped work like a review or a rename.

The right level depends on your work, so try low, medium and high on the same kind of task and read /usage afterward. Test max before adopting it broadly. It “may show diminishing returns and is prone to overthinking.”

Switching is cheap on this model. On Opus 5.5 with a subscription, changing effort mid-session keeps the cache. On most other models it doesn’t.

Now a mismatch I found in my own settings. My user settings have "effortLevel": "high". I’m on a Max plan, and that isn’t a recommendation for a $20 plan.

The model docs say a top-level effortLevel in your user settings “doesn’t count for Opus 5.5.” Opus 5.5 should start at medium until you pick a level with /effort or the /model picker.

My own session log disagrees. On Claude Code 2.1.281, 52 Opus 5.5 turns in one session recorded high, both as the effort and as a per-turn effort. /effort also shows high in my session. That matches what my settings file says, not what the docs describe.

I can’t tell whether the docs lag the software or something else set the level, and the log format isn’t documented. So don’t take my word or the docs’ word. If your default is high on a $20 plan, Opus 5.5 may be running above its medium default and using more of your limit.

Under opusplan, /effort shows the model you are on right now, so check it in plan mode to see Opus 5.5’s level. Here is how to see what your session really uses:

Run /effort with no arguments. It opens an interactive slider. Press Enter to save a level as your default, or s to apply it to this session only.
Read the session header. It shows the level next to the model name, for example “with low effort,” and the footer briefly shows it at startup and when it changes.
Use a status line. Its effort.level field reports the live level. Ultracode is not a distinct level there and reports as xhigh.
Clear a saved level. /effort auto removes the level you saved for the active model.

Claude desktop reads the same settings files as the terminal, so the same effortLevel line applies there. I couldn’t find where the desktop docs put the effort control. Mine currently shows ultracode, which is a Claude Code setting that sends xhigh plus workflows, not a level of its own.

To pin a level for one model, use modelSettings:

{
  "modelSettings": {
    "claude-opus-5-5": { "effortLevel": "medium" }
  }
}

Change the value when /usage gives you a reason.

There is one more cheap win. The playbook says Opus 5.5 “always thinks before it replies, and it decides how much,” so “think carefully” lines are dead weight.

Anthropic tested this in a chat product. Removing one “made replies start sooner, with no clear drop in quality.” I searched my project CLAUDE.md and my /wrap and write-post skills for lines like that and found none. Yours might have some.

Which model should do which job?

Pick the cheapest one that can do the job. Anthropic’s Help Center says Sonnet suits the large majority of coding work. Opus is for harder problems like large refactors, and it uses more quota. Haiku is for quick lookups and simple edits.

For a rough sense of the gap, look at API list prices: $4 in and $20 out per million tokens for Opus 5.5, against $2 and $10 for Sonnet 5. That is API pricing, not plan quota. Read it as a ratio of two to one, not a promise.

That is the logic behind opusplan. It runs Opus 5.5 in plan mode and Sonnet 5 for execution.

My usage shows the split working. On September 23 so far, ccusage put Sonnet 5 at about 52 percent of my tokens and Opus 5.5 at about 30 percent. That is a Max account and list-price accounting, so it shows the split, not what Pro would allow.

One catch, covered in my cost post. Each plan-mode toggle is a model switch, and each model has its own cache. So opusplan is cheapest when the context is small at the switch.

How has Opus 5.5 felt so far?

Since launch, it has felt faster and more focused. Anthropic says it generates output more than 30 percent faster than Opus 5, so that fits, though I didn’t time anything.

I also haven’t drained my limits, even after some heavy testing. My usage screen right now shows the current session at 12 percent and the weekly limit at 71 percent, with the reset on Friday morning. So it is not untouched, and a heavy week does show up.

For scale, ccusage counts 5.76 billion tokens on my account since Friday, September 18, which is roughly the same window as that weekly bar. About 97 percent are cache reads, meaning conversations being re-read. Fresh input and output add up to about 1 percent: around 37 million input and 22.5 million output tokens.

I can’t turn any of that into a Pro number. I found nothing from Anthropic on how tokens map to the bar, the bar also counts claude.ai, and I have no figures from my Pro days.

Read all of that with two caveats. I’m on Max, which gives at least 5x Pro’s usage. And most of my work stayed on Sonnet 5 through opusplan, so this was not an Opus-only test.

I’m not on Pro now, so I can’t tell you how Opus 5.5 feels on $20. That is why I’d watch /usage in your first week instead of trusting my impression.

How do you hand Opus 5.5 a task without wasting turns?

Give it the whole task in one message. Anthropic’s playbook says to name what “done” looks like and when you want it to stop and ask, then let it work. That works best when you already know what you want built, which is the gap between AI-assisted coding and vibe coding.

My read on why that saves usage: every extra turn re-sends your whole conversation. Five small messages are five full reads. Here is the shape, with a made-up project:

Add rate limiting to the login route.
Done means: 5 attempts per minute per IP, the new tests pass, and
npm run check is clean.
Stop and ask me only if a test fails and you can't explain why.

Three more habits from the playbook save turns too.

Type a follow-up while it runs. If you remember something mid-run, type it and press Enter instead of restarting. In the playbook’s words, “Runs are longer now, so a restart costs more.”

Keep the task list in a file. Ask Claude to keep a checklist in TASKS.md. A long run fills the context window, Claude Code then summarizes older turns, and a list in a file survives that.

Tell it which stops you want. Opus 5.5 sometimes stops to report or asks “Want me to continue?” Each stop costs you another turn, and every turn re-reads the context.

A short rule in CLAUDE.md fixes most of it. This one is adapted from the playbook:

When a step doesn't need my input, keep going. Put status notes in the
same message as your next action.
Stop and ask only when you can't continue without me, or before
anything destructive: deleting data, force-pushing, or changing
anything outside this repository.

Keep permission prompts on for destructive commands anyway. Claude Code auto mode adds a second wall: a classifier that reviews risky actions before they run.

Two habits from the Help Center are worth adding. Point Claude at files by path instead of pasting them, and ask for a plan before a big change. A plan is cheap, and a wrong multi-file diff is not.

When should you clear, compact or rewind?

Clear between unrelated tasks. The costs docs put it plainly: “When you want a fresh start instead of continuity, /clear costs nothing.” Run /rename first if you want to /resume the session later.

Compact at a natural break, not in the middle of a task. Compaction is itself a request that reads the whole conversation. After a break longer than the cache lifetime, it reprocesses all of it uncached.

To abandon a path, use /rewind. It truncates back to a prefix that is already cached instead of building a new one the way compaction does.

Back from a long break? On Pro and Max, Claude Code offers to resume from a summary, so later requests don’t carry the full history. Say yes unless you need the detail.

Keep the always-loaded stuff small too. Anthropic suggests a CLAUDE.md under 200 lines, with workflow instructions moved into skills that load only when invoked.

Run /mcp and disable servers you aren’t using. I measured what those cost in the cost post. One gotcha: editing CLAUDE.md mid-session doesn’t apply until /clear, /compact or a restart.

Which Claude Code features should a $20 plan skip?

Four of them cost more than they look.

Fable. It isn’t the default on any plan. On some plans it bills to usage credits, and the /model picker shows “Requires usage credits” on its row. On my Max plan, the usage screen shows a separate weekly limit for Fable instead. The docs I read don’t say which case Pro is in, so check the picker before you select it.

Fast mode. The playbook says it “needs extra usage turned on, and it costs more per token than standard mode.” Turning it on mid-session also causes a cache miss. API list price is $8 in and $40 out per million tokens, against $4 and $20 in standard mode. If you use it, turn it on at the start of a session.

The advisor. Each call re-reads the full transcript with no caching, and on subscriptions the advisor docs say advisor usage counts toward your plan limits. I keep advisorModel on Opus, but that is a quality purchase on a Max plan. On $20, /advisor off is the first thing to try if you are short on usage.

Agent teams. Agent teams use about seven times the tokens of a standard session when teammates run in plan mode. They are off by default. Leave them off.

Should a $20 plan use ultracode?

Not as a default. Ultracode combines xhigh effort with automatic workflows, so Claude plans a workflow for each substantive task. That applies to every task in the session, “so each request uses more tokens and takes longer than at lower effort levels.” The docs also say to drop back with /effort high for routine work.

The cost is the fan-out. A workflow spawns many agents, so a single run can use meaningfully more tokens than doing the same task in conversation, and runs count toward your plan’s usage and rate limits.

Anthropic’s own post on dynamic workflows says they “often use more tokens and are best suited for complex, high value tasks.” It adds that most traditional coding tasks “do not need a panel of 5 reviewers.”

I tried ultracode on Opus 5.5 in Claude desktop for a large code review, which is the kind of job the docs use as an example. That was on Max, so it is a look at the feature, not a Pro test. The desktop app draws on the same plan usage as the other Claude Code surfaces, and its approval card carries a token-usage caution.

If you review often, a repeatable pipeline is another route. Mine is in my automated code review pipeline post.

Three details matter more on $20:

You turn workflows on yourself. On Pro, use the Dynamic workflows row in /config.
The size guideline defaults to small. On Pro with Claude Code v2.1.271 or later, Claude aims for fewer than five agents.
Ultracode hides the Large workflow warning. That warning normally appears past 25 agents or 1.5 million projected tokens. With ultracode on, you don’t see it, because turning it on “already opts you in to large runs.”

If you want to try one, there is a cheaper route:

Ask for one workflow, not a whole session. Put the keyword ultracode in a single prompt. It runs one task as a workflow without changing the session’s effort level.
Start on a slice. Try one directory instead of the whole repo, and watch each agent’s token use in /workflows. You can stop the run there.
Keep the size small. Run /config workflowSizeGuideline=small if yours isn’t already.
Know what a limit does. On v2.1.271 or later, a run pauses at your five-hour limit and continues after the reset, instead of failing. It only pauses if the limit resets within 24 hours, so a weekly limit can still fail the agents. The workflows docs list every condition.

What do you do when you hit the limit?

You have four options.

Wait. The limit message shows the reset time. On Claude Code v2.1.234 or later, it can also wait and pick the task back up after the reset.
Turn on usage credits. Pro is eligible. Usage is billed at standard API rates, and you set a monthly spending cap. The Help Center has the details. Remember the cache drops to five minutes once you are on credits.
Switch model families. If you see a model-specific message like “You’ve hit your Opus limit,” switching to a model outside that family with /model keeps you working. That guidance sits in the costs docs section for seat-based plans, so check it against your own message. A session or weekly limit is shared across models, so switching won’t fix that one.
Move up a tier. Max starts at $100 and gives you “5x or 20x more usage than Pro.”

Ask for the review while you still have usage left. I once had to review generated code by hand because I had already hit the limit.

If you hit the session limit most days even with these habits, that is not you doing it wrong. It is a sign Pro may be too small for how you work, and the point where Max becomes worth pricing out.

The settings I’d start with

Here is the small version. I run it on Max, not Pro, so treat it as a starting point.

{
  "model": "opusplan",
  "env": {
    "CLAUDE_CODE_SUBAGENT_MODEL": "haiku"
  }
}

Add the CLAUDE.md stop rule from above and delete any “think carefully” lines. The built-in Explore and Plan subagents ignore the variable on its own, as I found in the cost post.

Then measure. Run /usage and read the Prompt cache (main) line for your hit rate and misses. If a habit doesn’t move a number there, it is just a habit.

The short version: How to get the most out of your $20 plan

Here is the whole post as a checklist.

Know where your config lives. ~/.claude/settings.json is for you everywhere, .claude/settings.json is for the project, and CLAUDE.md should stay under about 200 lines.
Read /usage first. Check the Prompt cache (main) line so you know where your limits actually go.
Start effort at medium, then experiment. Try low on scoped jobs and high on hard ones, check /effort for what you are really on, pin levels with modelSettings, and delete “think carefully” lines from your prompts, CLAUDE.md and skills.
Use opusplan. Opus 5.5 plans and Sonnet 5 types.
Send the whole task in one message. Say what “done” means and when to stop, keep a checklist in TASKS.md for long runs, and type follow-ups mid-run instead of restarting.
Add the stop rule to CLAUDE.md. Keep going when a step needs no input, ask before anything destructive, and keep permission prompts on.
Keep context small. /clear between tasks, /compact at natural breaks, /rewind to abandon a path, and /mcp to turn off servers you don’t use.
Accept the resume-from-summary offer. Do it after a break longer than an hour, when the cache has gone cold.
Skip the expensive features. That means Fable, fast mode and agent teams, and /advisor off is worth trying too.
Use ultracode for one big job, not all day. Put the keyword in a single prompt, start on a small slice, and drop back with /effort high.
At the limit, pick a route. Wait for the reset, turn on usage credits with a spending cap, or price out Max if it happens most days.

Which of these would save you the most on a $20 Claude plan, and have you checked it against your own /usage lately?