# Where Claude Code earns its keep, and where it doesn't

> Source: <https://okaneland.com/primer/how-to-use-claude-code/>
> Published: 2026-06-26 00:00:00+00:00

The Primer · Tools & Stacks

# Where Claude Code earns its keep, and where it doesn't

Vendor-neutral · no affiliate links

Claude Code is not an editor, it is an agent you delegate to from the terminal. Here is how to drive it, what the shared usage pool really costs, the six weeks in 2026 it visibly broke, and when to use Cursor instead.

Stop treating it like an editor. That is the first thing to get right, because almost everyone arrives from Cursor or Copilot and tries to use it the same way, then wonders why it feels wrong. Claude Code is an agent that lives in your terminal. You give it a task in plain language, and it reads your repo, edits files across the project, runs commands, reads the output, and loops until the job is done or it gets stuck. You are not steering it keystroke by keystroke the way you ride Cursor’s Tab. Keep one line in your head before we start: Claude Code is a junior engineer you delegate to, not an autocomplete you drive. Used well, it clears whole tasks while you do something else. Point it at the wrong work, or skip the review, and it will ship something broken with total fluency. Here is the practical version: how to drive it, what it costs, what the bad stretch of 2026 teaches, and exactly where it stops being worth your money.

## Set it up in five minutes

Claude Code runs in your terminal, inside VS Code and JetBrains as an extension, in the desktop app, and in the browser at claude.ai/code. Install it, open a real project (not a toy), and the first command to run is `/init`

. It reads your codebase and writes a `CLAUDE.md`

: a short file of project facts, conventions, and commands that Claude reloads every session. It bills against a Claude subscription, so if you already pay for Pro or Max for the chat app, you can start without a separate bill. More on that math below, because the pool is shared and it matters.

## The shift: you delegate, then you check

[Cursor amplifies your own typing](/primer/how-to-use-cursor/). Claude Code replaces a chunk of it. The good loop, the one Anthropic’s own [best-practices guide](https://code.claude.com/docs/en/best-practices) and every experienced user converge on, is four steps: explore, plan, implement, commit.

**Explore.** Ask it to read the relevant files and tell you how the thing works before it changes anything. Do not let it write code in the first message.**Plan.** Have it write a plan you can read and correct. Use plan mode (Shift+Tab) so it proposes before it touches a file. This one habit prevents most of the damage.**Implement.** Let it build against the plan you approved.**Commit.** Review the diff, commit the working step, then move on. Commit often so you can roll back cleanly when it breaks something, and it will.

The skill is not prompting. It is knowing what to hand off whole and what to keep on a short leash.

The leash is literal. By default Claude Code asks before it edits a file or runs a command, and you approve each action. You can let it auto-accept to move faster, but auto-running commands is a convenience, not a security boundary: an agent reading untrusted web content or a malicious repo can be steered into running something you would never approve. Keep the prompts on for anything that touches the network, the filesystem outside your project, or your credentials, and save the hands-off runs for work you have scoped tight.

## The three mistakes that burn your first week

**Treating it like Cursor.** People paste one line, expect a tidy inline completion, and get an agent that runs off and rewrites four files. Scope the task: tell it what to read, what to change, and what to leave alone.**Skipping the plan.** The single biggest split between people who love Claude Code and people who fight it is plan mode. Letting it code from a vague prompt is how you get confident, wrong, multi-file changes that are a pain to unwind.**Never making it check its own work.** An agent that writes code and never runs it is guessing. Tell it to run the tests, the type checker, and the linter, and to fix what breaks before it reports back. A loop that ends with “the tests pass, here is the diff” is worth ten that end with “I think this works.”

## Drive the context window like it is the budget

What quietly decides whether Claude Code does good work is the context window: how much of your code and conversation it can hold at once. It is finite, and a long, messy session fills it with stale detail until the model loses the plot. Three habits keep it sharp:

Start a fresh context for each logical unit of work. A thread that has wandered through three unrelated problems makes worse decisions on the fourth.`/clear`

between tasks.It summarizes the session so far and frees room, keeping the thread alive without the clutter.`/compact`

when a long task must continue.**Hand big jobs to subagents.** Claude Code can spin up[separate agents](https://code.claude.com/docs/en/sub-agents)for sub-tasks, each with its own clean context, so the main thread stays focused. This is how you stop a large job collapsing under its own history.

And keep `CLAUDE.md`

short and current: under a couple hundred lines, pointing at real files instead of pasting them, with a new line added every time the agent repeats a mistake. The [memory file](https://code.claude.com/docs/en/memory) does more to keep the agent on your rails than any clever prompt.

## Claude Code pricing: one shared pool, two meters

Claude Code has no separate price: it bills against your Claude subscription, the same usage pool as the Claude chat app, on Pro ($20/mo) or Max ($100 and $200/mo). The subscription you thought you understood writes you a surprise here, so learn the mechanic. That is the catch most people miss: a heavy Claude Code afternoon eats the same allowance as your chats. (API pay-as-you-go is a separate, metered track if you would rather pay by the token.)

There are two meters on that pool. A rolling five-hour limit that has always been there, and weekly caps Anthropic [announced in July 2025](https://techcrunch.com/2025/07/28/anthropic-unveils-new-rate-limits-to-curb-claude-code-power-users/) and switched on a month later, after a minority ran agents around the clock: one overall weekly limit, and a second, tighter cap specifically on the most capable model. That second cap is the one that bites, because the heavyweight model is exactly what you reach for on hard agentic work, and it drains the fastest. Anthropic estimated the weekly caps would hit fewer than 5% of subscribers; those few are the heavy daily users, and the backlash was loud, with developers reporting a full weekly quota gone in a day or two of real work.

The practical read: do the everyday work on the cheaper, faster models and save the most capable one for the tasks that genuinely need it. Watch your usage. If you are hitting weekly caps, that is the signal you are either doing serious volume (in which case the API track or a higher tier may be cheaper) or handing the agent work you should be scoping tighter.

## The 2026 degradation: when the wheels came off, and what it teaches

Here is a receipt worth more than any feature list. For roughly six weeks in early 2026, Claude Code visibly got worse, and the story of why is the best argument there is for never trusting an agent you cannot see.

Users reported it turning forgetful, repetitive, and lazy. An AMD AI director, Stella Laurenzo, [data-mined 6,852 of her own sessions](https://github.com/anthropics/claude-code/issues/42796) and found the behavior had measurably shifted: the model went from reading the code 6.6 times per edit to 2.0, and the share of edits it made without reading the file first jumped from 6.2% to 33.7%. It had stopped doing its homework. Developers called it “AI shrinkflation.”

Anthropic [published a postmortem](https://www.anthropic.com/engineering/april-23-postmortem) on April 23, 2026 and confirmed the decline was real, and (this is the part that matters) that the model weights and the API were never touched. Three separate changes to the product layer, the harness around the model, had each quietly dented quality: a March reasoning setting cut from high to medium to shave latency, which Anthropic later called “the wrong tradeoff”; a caching bug that wiped the model’s reasoning every turn and made it forgetful; and a brief verbosity cap that measured about 3% worse on coding and lasted four days. All three were fixed by April 20, and Anthropic reset everyone’s usage limits as an apology.

The lesson is not “Claude Code is unreliable.” It is more useful than that, and less reassuring: you are renting an agent built on a stack you do not control, and quality can shift under you without warning, from a setting you will never see. The only defense is the one the candid Cursor fans repeat. Make it verify its own work, and read the diff yourself. The builders who barely noticed the rough patch were the ones who already checked every change against the tests. The ones who got burned had stopped looking.

## Where it stops being worth it

The Primer rule is to know your off-ramp before the bill, or the bug, surprises you. Claude Code is the right tool for delegating real, multi-file work you can describe and then check. Here is when to reach for something else:

**Tiny, in-context edits.** Renaming a variable or tweaking the line on your screen does not need an agent. That is what an editor’s inline completion is for, and firing up a whole agentic loop for it wastes time and budget.**Work where you want to feel every change.**[The METR study](/study/does-ai-coding-make-you-faster/)found experienced developers were 19% slower with AI on large codebases they knew cold, while believing they were faster. On code you know intimately, steering the keystrokes yourself often beats delegating and reviewing.**You are watching cost and only want completions.** A completion-first tool like Copilot is cheaper and sits in your editor; you do not need an agent’s power, or its bill. The tools we currently stand behind are on[the Palette](/palette/).**Huge, mature codebases.** A million-line repo is far more than any model holds at once. Claude Code handles this better than most, because it reads selectively instead of stuffing everything into context, but it still needs you to scope tightly, and the review tax climbs with the stakes.**No code can leave the building.** Claude Code sends your code to Anthropic’s models. Air-gapped or regulated work needs a bring-your-own-key tool pointed at a local model, not any hosted agent.

## Claude Code vs Cursor: use both, and here is the split

Claude Code and Cursor are different shaped tools, and most serious builders run both. That is the answer the “X vs Y” posts dodge. [Cursor](/primer/how-to-use-cursor/) is an editor: you live in it, and its Tab autocomplete amplifies your own typing on code you are actively shaping. Claude Code is an agent: you delegate a whole task to the terminal and check the result. Reach for the editor when you want to feel every line; reach for the agent when you want a defined job done off your plate. The [common 2026 verdict](https://www.builder.io/blog/cursor-vs-claude-code) is not to crown a winner but to [keep both in the stack](/primer/ai-coding-stack/): one to make your hands faster, one to take work off them.

Claude Code is the most capable terminal agent available, and on the right task it clears work nothing else can handle. The shared usage pool is the line item to watch, the weekly cap on the top model is the one that stings first, and the agent is only ever as safe as your review habit. Delegate the work you can describe, make it prove the result, read every diff, and keep one eye on the meter. Do that and it earns its keep. Skip the review and it will hand you a confident, broken result while you are looking the other way.

## Sources

| Source | Link |
|---|---|
| Claude Code docs, Overview |
|