Anthropic's latest guidance for Claude Code asks developers to stop doing five things by hand: steering the model, approving commands, saying no to risky actions, checking the work, and starting sessions. Each of those jobs now moves to the model, the harness (the software that wraps the model and runs its tools), or the environment where the work executes. The developer's role shifts from watching one session at a time to managing many sessions in parallel.
The numbers behind the change are large. Anthropic's engineering team went from roughly 2,500 code changes per day in May to more than 30,000 per day in September, about a 12x increase. A member of Anthropic's Claude Code team laid out the practices behind that jump in a talk at the AI Engineer conference in November 2026. The core observation: most developers still run Claude Code sequentially, in a single session, while Anthropic engineers oversee dozens of concurrent sessions.
The five jobs at a glance
| Job | Old habit | What takes over |
|---|---|---|
| Steering | Correcting the model step by step, long rule files | The model itself, plus a lean CLAUDE.md |
| Approving | Confirming every command, or skipping permissions | Auto mode and its classifier |
| Saying no | Asking the model in a prompt not to do something | Deny rules, sandboxing, cloud sessions |
| Checking | Reading thousands of changed lines afterward | Pass/fail gates, hooks, review agents |
| Starting sessions | Opening one session per subtask | Claude Code Projects with an orchestrator |
The rest of this article goes through what to change for each one, starting with the two that deal with dangerous commands.
Approvals: let the classifier decide, inside limits you set
The older workflow offered two choices: confirm every command by hand, or skip permissions entirely and accept the danger. Auto mode, now the default in Claude Code's terminal and desktop apps, replaces both. An independent classifier evaluates each proposed shell command before it runs. Commands it judges safe, such as running tests or installing packages, go through. Commands it is unsure about stop.
By default, auto mode limits write access to the active directory and repository and intercepts risky moves such as pushes to deployment branches. A deploy to a staging server, for example, is held back when the destination repository sits outside the trusted scope.
You widen that scope on purpose rather than by accident:
- Add plain-English rules to settings.json that name your trusted GitHub organizations, Amazon S3 buckets and internal domains.
- Run
/auto-mode-setupto have Claude Code analyze your project history and recent sessions and draft a permission configuration for you.
An Anthropic study from August 2026 gives the case for trusting the classifier over your own attention. Human developers in the loop caught 14% of clearly dangerous commands. Auto mode blocked 89%.

▲ Command screening before execution
Saying no: hard blocks for anything you cannot undo
An 89% block rate still means roughly 1 in 10 dangerous commands can pass. Auto mode alone is not a security boundary. That gap is the job of deny rules: entries in .claude/settings.json that act as hard programmatic blocks. They are evaluated before the classifier and apply unconditionally.
The test for what deserves a deny rule is a single question: "Can I take it back?"
- Yes: edits to code, tests and docs, and test runs. These side effects can be undone through version control, so the model can handle them.
- No: permanent file deletion, exposure of secrets or credentials, and anything sent to the outside world. These need deny rules.
There is an important difference between asking Claude in a prompt not to touch secrets and enforcing that restriction in the permissions configuration. A prompt is a request. A deny rule on reading or writing files such as .env or the ~/.ssh directory is a block.
Deny rules on commands do not cover everything, either. A test run through a package manager such as npm executes third-party code from installed dependencies. That code could try to read environment variables or SSH keys and send them elsewhere, and no suspicious shell command would ever appear for the classifier to flag. Two environment-level defenses address this:
/sandboxisolates processes at the operating system level, restricting file access and outbound network reach.- Cloud sessions run the job on a disposable remote machine that holds none of your local credentials. This is the suggested home for long, multi-hour autonomous tasks.
Checking: build the gates before the work starts
When sessions run unattended for hours, reading thousands of changed lines afterward is not practical. And a result can look finished without being right. Take a migration of an authentication system to a new API endpoint. The same prompt could produce a version that leaves the old endpoints active, one that only works for new logins, or one that logs out every active user. All three might pass a surface check.
The answer is to define pass/fail gates along the way rather than one review at the end:
- Set objective milestones. For code, that means automated tests or screenshots of the UI. For knowledge work such as a market research report, it means checks like "every citation link resolves" and "every figure matches the spreadsheet."
- Ask Claude to define "done" and "good" first. This pushes the model to evaluate and iterate on its own draft before it shows you a first version.
- Automate the checks with hooks. Hooks are scripts that fire on events in the session. One setup runs linting after each tool use, task-level tests when a task completes, and the full test suite when the session stops.
- Get the exit code right. The usual default sends the wrong signal, as the table shows.
| Hook exit code on failure | What Claude Code does |
|---|---|
| 1 (the usual default) | Marks the task complete |
| 2 | Goes back and fixes the failure |
A hook script that fails with exit code 1 lets a broken task pass as finished. Exit code 2 is what sends Claude Code back to repair it.
After the automated gates comes review by other agents. In Anthropic's internal pipeline, every pull request goes through fresh, independent Claude review agents before a human engineer looks at it. Those agents detect bugs, verify severity and filter out false positives before posting comments.

▲ Automated test, rework and review loop
Steering: cut your CLAUDE.md down to what Claude cannot find
With Claude Opus 4.5, developers had to watch, prompt and correct the model step by step. Many also filled CLAUDE.md, the instruction file Claude Code reads for a project, with forceful directives such as "IMPORTANT" and "NEVER" in capital letters.
With Claude Opus 5.5, that habit works against you. Aggressive or redundant instructions often backfire, leading to excess tool calls and worse performance. The recommended filter is strict: keep only information Claude cannot discover on its own by inspecting the repository. Anything it can infer from the files goes. Hidden architecture patterns and links to external documentation stay.
One way to apply this beyond code is to run an entire business from a single directory and use CLAUDE.md as a routing map. The file does not hold the knowledge itself. It points to where the business wiki, the brand assets and the financial ledgers live.
To clean up an existing file, run /doctor prompt-audit. It compares your instructions against the active model and flags rules that are bloated or counterproductive.
Starting sessions: one root session, many workers
The last manual step is opening a new session for every subtask. Claude Code Projects, in beta for Pro, Max and Ultra plans, removes it. One root session receives the full backlog for a project, such as a week of milestones, and spins up an independent worker session for each deliverable.
Project settings let you assign different models to different roles. One pairing puts a high-level reasoning model, Claude Fable 5.2, in the orchestrator role, with Claude Opus 5.5 workers doing the execution. The structure is not limited to programming. It applies to client deliverables, research briefs and video production pipelines as well.
What to change this week
The common thread is that effort moves away from hands-on execution and toward designing the harness, the environment and the gates. That appears to matter most for people who cannot judge every command themselves, since the guardrails do work a reviewer otherwise would. A practical order of operations:
- Run
/doctor prompt-auditand remove everything in CLAUDE.md that Claude can learn from the repository. - Run
/auto-mode-setup, then list your trusted repositories, domains and storage buckets in settings.json. - Apply "Can I take it back?" to your workflow and write deny rules for every "no": deletions, credential files, outbound messages.
- Use
/sandboxlocally and move long autonomous runs to cloud sessions. - Add hooks for linting and tests, and confirm that failures exit with code 2.
- Pick a substantial project, hand the backlog to a single root session in Claude Code Projects, and then automate whichever manual bottleneck is still left.


