Rethinking Claude Code Best Practices with Lydia Hallie, Anthropic
As AI models and Cloud Code's harness have improved, the role of the human developer has shifted from actively steering, approving, and starting nearly every
By Sean WeldonRethinking Claude Code Best Practices: From Inline Supervision to Distributed Oversight
Abstract
This synthesis examines a structural shift in agentic coding practice: the human developer's role has moved from step-by-step supervision of individual tool calls toward management of many concurrent, long-running, self-verifying sessions. Drawing on reported Claude Code deployment data - growth from approximately 2,500 code changes per day in May to more than 30,000 per day in September - and an internal safety study showing human reviewers caught only ~14% of clearly dangerous commands versus 89% for an automated classifier, this analysis argues that oversight previously performed inline by humans must now be explicitly reassigned to one of three substrates: the model, the harness, or the execution environment. Mechanisms examined include auto mode classification, permission deny rules, operating-system-level sandboxing, disposable cloud sessions, hook-enforced verification, and orchestrator/thread decomposition. Configuration guidance and residual failure modes are identified for practitioners adopting these patterns.
1. Introduction
Agentic coding refers to the delegation of multi-step software engineering tasks to a language model operating within a tool-using harness, where the model can read, edit, and execute code with varying degrees of human supervision. Earlier in 2026, sessions built on Opus 4.5 required near-continuous human involvement: developers either approved each tool invocation manually or disabled permission checks entirely via a dangerously-skip-permissions mode. No automated mechanism existed to classify command risk, so the human occupied the position of inline controller by necessity rather than choice.
This posture has since changed substantially. Contemporary sessions may run for hours, execute in parallel across dozens of instances, verify their own outputs against tests or builds, and spawn subordinate sessions to complete subtasks. Anthropic's internal metrics quantify this shift directly, reporting a rise from roughly 2,500 code changes per day in May to more than 30,000 per day in September - an order-of-magnitude increase that is difficult to reconcile with a model in which every change passes through manual human review.
The central claim examined in this paper is a conservation principle for supervisory responsibility, stated directly in the source material: "Everywhere that we now step out of that loop, something else has to take over. And this is either the model, the harness, or the environment that it's running in." Removing the human from a given checkpoint does not eliminate the need for that checkpoint; it relocates the responsibility. This analysis traces that relocation across three domains - steering, safety enforcement, and output verification - before extracting implementation-level findings and discussing broader implications for practitioners managing agentic workflows at scale.
2. Background and Related Work
Several harness-level constructs underpin this analysis. Auto mode, the default permission mode since August, runs a separate classifier against nearly every tool call except reads and edits within the project directory, automatically permitting commands it judges safe (running tests, installing dependencies) while blocking those it cannot confidently categorize. Permission deny rules are declarative, harness-enforced prohibitions that are checked before the auto mode classifier is ever invoked. Sandboxing restricts filesystem and network reachability at the operating-system level, applying to a command and its full process tree rather than only the top-level invocation.
A further construct, the cloud session, relocates execution to a freshly provisioned, disposable machine containing only a copy of the repository and no local secrets. Hooks are scripts triggered at defined lifecycle events - after an edit, before a task is marked complete, before a session ends - providing deterministic enforcement that prompting alone cannot guarantee. Claude Code Projects, currently in beta, composes these primitives into an orchestrator/thread topology. Model capability itself functions as a substrate in this framework: Opus 5.5 is reported to infer user intent and codebase structure more reliably than Opus 4.5, reducing the need for mid-session correction, while Fable 5.2 is characterized as comparatively stronger at judgment and decision-making tasks suited to orchestration.
3. Core Analysis
3.1 Reassigning Steering to Model Capability and Configuration
As model capability increases, configuration artifacts calibrated for weaker models can become counterproductive. CLAUDE.md files containing emphatic directives - "important!", "never do this!" - are reported to degrade behavior under stronger models, inducing off-trajectory reasoning and increasing tool-call counts rather than improving compliance. The recommended invariant is that CLAUDE.md should encode only information Claude cannot infer from the codebase itself, such as references to legacy services not directly visible in the repository. A doctor prompt audit command is provided to automatically check CLAUDE.md and skills files against what a target model actually requires, flagging obsolete or counterproductive instructions.
3.2 Reassigning Safety Enforcement to Harness and Environment
The internal safety study is the most consequential empirical finding in this material: human reviewers caught only ~14% of clearly dangerous commands, while the auto mode classifier blocked 89%. This result motivates auto mode as the default rather than manual approval, but it also establishes a residual failure rate - roughly 10% of dangerous commands pass through automated classification regardless. Closing this gap requires harness-level guarantees rather than probabilistic classification. Deny rules serve this function: because they are evaluated before the classifier runs, a matching deny rule is never subject to classifier judgment at all. The decision criterion offered for what warrants a deny rule is reversibility - "if Cloud gets this wrong once, can I take it back?" Incorrect code is revertible; a deleted set of uncommitted changes or a leaked credential is not.
A distinct limitation emerges from the scope of permission checks themselves: "permissions only decide if a tool call runs, but they cannot limit what it can reach once it's running." A command such as npm test may appear safe at the point of approval, yet a compromised dependency executed during that test run could still exfiltrate the contents of a .env file or SSH key. Sandboxing addresses this by restricting, at the OS level, which files, folders, and hosts a command and its child processes can access - a scope that plain deny rules, which inspect only the top-level invocation, cannot provide. Even sandboxing has a defined boundary: it covers shell commands Claude runs and their children, but not Claude's own files, MCP servers, or hooks, and by default still permits reading most of the local machine unless additional rules protect specific assets such as SSH keys.
Cloud sessions remove an entire class of risk by construction: each session executes on a fresh machine with no local secrets, .env files, SSH keys, or GitHub tokens present to exfiltrate. Network access on these machines is restricted by default to package registries and GitHub, with other domains requiring explicit permission, and API keys needed mid-session can be supplied as network secrets without the key value ever being exposed to the model. Nonetheless, the source material notes that disposability does not eliminate downstream risk: "it's still good to remember that this machine is disposable, but the things that leave it aren't" - commits, messages sent via connectors, and other outputs persist and remain subject to deny rules and auto mode evaluation.
3.3 Reassigning Verification to Hooks and CI
Inline human review previously served as the verification checkpoint for every change. Removing that checkpoint without replacement produces inconsistency: identical prompts can yield different, individually plausible but divergent outcomes - for example, differing edge-case handling across repeated runs of an authentication migration task. Prompting alone, including explicit statements of what "done" should look like, does not guarantee compliance. Hooks provide the deterministic alternative, running scripts at defined points such as after file edits (triggering a linter) or before a task is marked complete (triggering relevant tests). A specific implementation detail carries operational weight: hook scripts must exit with status code 2, not 1, to force the session to revisit a failure; exit code 1 still permits the task to be marked complete despite the failure. At the orchestration level, CI functions as a consistent backstop applied uniformly regardless of session configuration, with CI auto-fix allowing the model to resolve its own failed checks and "merge when ready" enabling automated merging once checks pass, calibrated to the assessed risk of the change.
4. Technical Insights
Several concrete implementation findings follow from the preceding analysis. The relative ordering of deny rules and classification matters operationally: because deny rules are checked before the auto mode classifier runs, they provide a hard guarantee unavailable through classifier-based blocking alone, which is why irreversible actions (reading .env files, including via indirect commands like cat) should be encoded as deny rules rather than left to model or classifier judgment. The reversibility test - whether an erroneous action can be undone - offers a general decision procedure for allocating actions between deny rules and model autonomy.
The distinction between permission scope and sandbox scope is a recurring trade-off: permissions gate whether a tool call executes at all, while sandboxing constrains what that call and its descendants can subsequently access. Neither alone is sufficient; a command judged safe at approval time can still reach sensitive resources through dependencies invoked during execution. Hook exit-code semantics represent a narrow but consequential implementation detail - a single incorrect exit code silently disables the enforcement the hook was designed to provide. Finally, the orchestrator/thread model in Claude Code Projects reflects a model-selection trade-off distinct from safety configuration: orchestration benefits from a model suited to judgment and task decomposition (Fable 5.2), while execution threads benefit from a model suited to sustained tool use (Opus 5.5), and these can be configured independently.
5. Discussion
The data presented - a twelvefold increase in daily code changes alongside a safety study showing automated classification substantially outperforming human review for dangerous command detection - suggests that the inline-human-review model was not merely inconvenient at scale but measurably less reliable than the harness mechanisms that have replaced it for certain classes of risk. This reframes "removing the human from the loop" not as a reduction in safety rigor but as a reallocation toward mechanisms better suited to high-volume, repetitive risk assessment, while reserving human judgment for configuration decisions (which deny rules to set, which risk tolerance to encode in auto mode settings) that classifiers cannot make for themselves.
A notable gap in the current framework is the explicit acknowledgment that automated enforcement remains incomplete: roughly 10% of dangerous commands pass through the classifier, and sandboxing's default configuration still permits broad filesystem reads unless specifically restricted. This implies that current best practice is necessarily layered and conjunctive - deny rules, auto mode, sandboxing, and cloud isolation each covering a different risk surface - rather than any single mechanism providing comprehensive protection. Future investigation might focus on quantifying residual risk across these layers in combination rather than in isolation, and on whether orchestrator/thread decomposition introduces new coordination failure modes not captured by the current safety studies, which appear to focus on single-session command classification.
6. Conclusion
This analysis has traced the redistribution of three supervisory functions - steering, safety enforcement, and verification - from the human developer to the model, harness, and execution environment as Claude Code sessions have scaled in volume and duration. The practical takeaway for practitioners is that autonomy should be adopted alongside, not instead of, explicit configuration: deny rules for irreversible actions, sandboxing for resources beyond what permissions can govern, cloud isolation for secret exposure, and hooks with correct exit-code semantics for guaranteed verification. As orchestration patterns such as Claude Code Projects mature, the relevant design question for teams shifts from "how much should a human review" to "which substrate is responsible for which category of risk," a question this source material answers concretely but incompletely, leaving combined-layer risk measurement as an open area for further study.
Sources
- Rethinking Claude Code Best Practices - Lydia Hallie, Anthropic - Original Creator (YouTube)
- Analysis and summary by Sean Weldon using AI-assisted research tools
About the Author
Sean Weldon is an AI engineer and systems architect specializing in autonomous systems, agentic workflows, and applied machine learning. He builds production AI systems that automate complex business operations.
At 22Atlas, the studio I run, we put Claude to work for clients, and 22Atlas on Claude covers how.
Sean Weldon builds apps and custom software at 22Atlas.