Lydia Hallie works on the Claude Code team at Anthropic. Her AI Engineer talk (re-recorded at home after the live demo had technical trouble) is a 17-minute audit of the Claude Code advice Anthropic itself published earlier in the year. Her claim is that most of that advice was written for models that stopped early and needed correcting, and that with Opus 5.5 and Fable 5.2 a lot of it now gets in the way. Each habit gets the same question: drop it, keep it, or move it somewhere else.

From one session to dozens

Slide: code changes merged per day to Anthropic’s monorepo went from 2,500 in May 2026 to more than 30,000 in September 2026

She starts with what a session looked like on Opus 4.5. You approved commands by hand (or ran --dangerously-skip-permissions), you kept nudging the model, and your CLAUDE.md filled up with IMPORTANT! lines. Sessions at Anthropic now run for hours, dozens at a time, check their own results, and sometimes start other sessions. The number she uses to make the point comes from Anthropic’s October source-control post: merged changes to the monorepo went from about 2,500 a day in May to more than 30,000 a day in September.

The people running those sessions have turned into managers of them, and that changes what the best practices need to cover.

Every step out of the loop needs a replacement

Slide: out of the loop. Steering, approving, saying no, checking and starting are taken over by the model, the harness and the environment

The old advice was about five human jobs: steering the session, approving commands, saying no, checking the output, and starting the session. Her framing for the rest of the talk is that whenever the human stops doing one of these, the model, the harness or the environment has to do it instead. That leaves two questions. Is the code still good if nobody approves each step? Is it safe if nobody is watching for hours?

Use the defaults, then trim CLAUDE.md

Slide: a CLAUDE.md with “Think hard and be thorough”, “Keep going until it’s done”, an IMPORTANT line, “We’re on Node 18” and “src/legacy still serves our mobile apps”

The first step is just using current defaults: Opus 5.5 and auto mode, which became the default permission mode in August. The model needs much less steering mid-session, so the instructions file should shrink as well. Lines like “think hard”, “keep going until it’s done” and capitalised warnings now cause harm, she says, because they push the model off track and produce extra tool calls and worse results.

What stays in CLAUDE.md is what Claude can’t work out from the code. In her example, a src/legacy directory that still serves the mobile apps without being referenced anywhere stays in. The stack and the folder layout come out. A /doctor prompt-audit command checks CLAUDE.md and your skills against the current model and flags what it no longer needs.

Auto mode runs a classifier on everything except reads and edits inside the project. It allows commands it knows are safe and blocks ones it isn’t sure about. By default it trusts only the current folder and repo, so a push to a separate deploy repo gets blocked. You fix that by listing trusted repos, buckets and internal domains in plain English under autoMode.environment in settings. That text goes straight to the classifier.

Safety: rules for what you can’t take back

Slide: 14% of dangerous commands caught by people versus 89% blocked by auto mode, from 1,053 paid testers with one dangerous command swapped in per session

In Anthropic’s August study with 1,053 paid testers, one dangerous command was swapped into each session. People caught 14% of them and auto mode blocked 89%. That’s much better than a human, but roughly one in ten still went through. For a guarantee you need the harness, and that’s where an old practice survives: permission rules. A deny rule is evaluated before the auto-mode classifier, and a matching tool call never reaches it.

Slide: “Can I take it back?” Yes means leave it to the model (edits, anything git can revert); no means make it a rule (deletes for good, exposes a secret, sends something outside)

Her test for what deserves a rule is whether you can undo it. Wrong code can be reverted, so leave it to the model. Deleting uncommitted work, reading a secret into the transcript, or sending data outside can’t be undone, so those become rules. Read(./.env) and Bash(git reset --hard *) are her examples.

Rules stop tool calls; sandboxes stop side effects

Slide: on your machine, Read/Edit/WebFetch and Bash npm test with its child processes run inside the sandbox; MCP servers and hooks run outside it

Permissions decide whether a tool call runs. They can’t limit what it touches once it’s running. npm test is a harmless command that executes dependency code you never wrote, and a compromised package can read .env or ~/.ssh and post them to a server. A human approver would have clicked allow as well, because there was nothing visible to refuse.

The local fix is the sandbox ("sandbox": {"enabled": true}). With it on, the same deny rules are handed to the operating system and apply to the command and every child process, and network access is limited to approved hosts. She adds that by default the sandbox can still read most of your machine, so ~/.ssh needs its own rule. The sandbox only covers shell commands, though. Claude’s own file tools, MCP servers and hooks still run on your machine.

Her preferred end state is a cloud session: a fresh machine with a clone of the repo, which keeps running after you close the laptop. .env, SSH keys and the GitHub token aren’t in git, so they aren’t there. API keys go in as network secrets that are used without being sent to the model, and egress defaults to package registries and GitHub. The machine is disposable but pushes and connector messages leave it, so auto mode and the committed deny rules still apply in the cloud.

Verification checkpoints, enforced by hooks

Slide: hooks; exit 2 sends Claude back to fix it, exit 1 lets the task be marked completed

Nobody reads a 63-file diff at the end of a three-hour run. Her example is “move auth over to the new API”, where the same prompt can produce a migration that leaves the old API in place, one that only covers new logins, or one that logs everyone out. All three look reasonable. The fix is checkpoints that return pass or fail (a test, a build, a screenshot) and that you review in place of the whole diff.

The cheapest version goes in the prompt: say what done looks like, ask for tasks that each have their own test, and ask Claude to show the actual output, since you weren’t there to see it. A prompt isn’t a guarantee, so hooks handle the checks that have to happen: lint on PostToolUse, the relevant tests on TaskCompleted, the whole suite on Stop. The practical detail most people will miss is exit codes. A hook that exits with 1, which is what most test runners return on failure, still lets Claude Code mark the task complete. Only exit code 2 sends Claude back to fix it.

CI, review by risk, and an orchestrator session

With checks in place, sessions can run in parallel on their own machines without worktree juggling. The human still starts each one and reviews each one. Hallie calls CI the most important piece at this stage, because it runs the same checks on every PR however the session was configured. CI auto-fix lets Claude see a failing check and go back to it, and merge-when-ready lets GitHub merge once checks pass. That isn’t the default and depends on risk. On her team every PR first gets a Claude review from a fresh context, and a separate group of agents checks each bug it reports. Docs and copy changes need no human reviewer, ordinary product changes get one, and risky ones get two.

The last step is not starting sessions yourself. In Claude Code projects (in beta), one orchestrator session splits the work, starts a thread per task, and sends back anything that isn’t actually finished. She suggests running different models in the two roles, Fable for the orchestrator that decides and judges and Opus 5.5 for the threads that do the work, and says context management is handled automatically in this setup.

Slide: steering becomes the model, approving becomes auto mode, saying no becomes deny rules and the environment, checking becomes tests, hooks and CI, starting becomes Claude

Her summary is that none of the old practices went away. They moved, and the human’s job shrinks to starting the first session and reviewing what comes out. Her suggested first experiment: give Claude something much bigger than usual, make sure CI catches what you care about, configure the cloud environment’s network access, secrets and setup script, then watch where the session stalls. Whatever stalls it is the next thing to hand over.

Key takeaways

  1. Old prompt scaffolding now hurts. Remove “think hard” and IMPORTANT! lines from CLAUDE.md and keep only facts the model can’t infer from the code.
  2. Auto mode beat people at catching dangerous commands in Anthropic’s study (89% blocked against 14% caught), but about one in ten still got through, so anything irreversible belongs in a deny rule, which is checked before the classifier.
  3. Permission rules control whether a call runs, not what it does once running. Use the OS sandbox or a cloud session to stop dependency code from reading secrets or calling unknown hosts.
  4. The local sandbox covers shell commands and their children only. MCP servers, hooks and Claude’s own file tools stay outside it.
  5. Hook scripts that should block completion must exit with code 2. Exit code 1 lets the task be marked done anyway.
  6. Review checkpoints that return pass or fail instead of whole diffs, and match the number of human reviewers to the risk of the change.
  7. For many parallel tasks, one orchestrator session (Fable) that delegates threads to a worker model (Opus 5.5) replaces a human juggling eight terminals.

Source

  • Talk: “Rethinking Claude Code Best Practices”
  • Speaker: Lydia Hallie, Member of Technical Staff, Anthropic
  • Venue: AI Engineer (re-recorded after the live session)
  • Duration: 17:31
  • Video: https://www.youtube.com/watch?v=vlfCjWuv4es