Most people start agentic coding with a mental toggle. Either they code manually, or they hand the task to Claude. Manual mode. AI mode. Two separate worlds.
This framing is wrong, and it creates friction every time you switch between them. You end up either micromanaging the agent (writing the code yourself and using Claude as autocomplete) or over-delegating (throwing a vague prompt and hoping for the best).
The better model: one continuous system where your involvement scales with the task.
The autonomy dial
Think of your involvement as a spectrum, not a switch.
Full autonomy
Low-risk, well-defined tasks. Renaming variables across a codebase, generating boilerplate, writing test scaffolding, formatting. Claude runs. You review at the end.
Guided autonomy
Medium tasks with clear specs. Building a new component that follows existing patterns, adding a TRPC route that mirrors one already in the codebase. You spec it, Claude builds it, you review.
Close oversight
High-risk or ambiguous tasks. Database migrations, authentication logic, payment integrations. You review each step before Claude continues.
Pair mode
Exploratory or architectural work. You're thinking out loud, Claude is providing options, you're making decisions in real time. Neither of you is "driving" alone.
The decision isn't binary. Some tasks need you at every step. Others need you only at the start (the spec) and the end (the review). Most tasks fall somewhere in between.
Contexts: same system, different attention
This is an ECC concept I use daily. Instead of thinking about "modes," I think about contexts — different attention levels applied to the same system.
- Dev context: "Write code first, explain after." Claude produces, you verify. Fast iteration on well-understood problems.
- Review context: "Read thoroughly before commenting." You're examining output carefully, checking for edge cases, verifying business logic.
- Research context: "Read widely before concluding." Claude explores the codebase, reads documentation, maps dependencies — before writing a single line.
These aren't separate tools. They're the same Claude Code session with different instructions. You can set these as custom contexts in Claude Code, switching between them based on what the task demands.
> "Read the auth middleware and the session handling code.
Don't change anything yet — just tell me how they connect."
[Claude explores, maps the flow]
> "Good. Now add magic link support. Follow the existing
session pattern exactly. Don't touch the middleware."
[Claude implements with full context]
Same session. Same tool. The only thing that changed was your level of engagement.
Permission modes: the built-in dial
Claude Code ships with three permission modes that map directly to this spectrum.
Plan mode
Claude must get approval before every action. Use this for high-risk work: migrations, auth, anything that touches production data. Enter with Shift+Tab or /plan.
Auto mode
Claude runs freely within safety limits. It can read files, write code, run builds — but still asks before destructive operations. This is the default for most work.
Bypass permissions
Full autonomy. Claude runs everything without asking. Use this only for well-defined, low-risk tasks where you trust the spec completely. Think: batch renaming, formatting, generating types.
The mistake I see most often: people stick to one mode for everything. They use auto mode when they should be in plan mode (and miss critical decisions), or they use plan mode when auto would be fine (and waste time approving trivial actions).
Match the permission mode to the risk level. That's it.
What this looks like in practice
Here's a typical 30-minute session for me. Notice how the involvement level shifts naturally:
- Start in plan mode. I describe a feature — a new API endpoint with validation. Claude proposes a plan. I adjust two steps and approve. (Close oversight — 3 minutes.)
- Switch to auto mode. Claude implements the plan. Writes the router, the schema, the types. I'm watching but not intervening. (Guided autonomy — 15 minutes.)
- Review the output. I read through the diff, check the validation logic, verify the error handling. I catch one edge case Claude missed. (Review context — 5 minutes.)
- Quick fix in auto mode. I tell Claude to handle the edge case. It fixes it in 30 seconds. (Full autonomy — 1 minute.)
- Commit. Done.
No mode switching. No jarring transitions. One continuous workflow with my attention allocated where it mattered most.
The feature shipped in 30 minutes. Without the agent, it would have been two hours. But the quality of my involvement — the spec, the plan review, the edge case catch — is what made the output production-ready. The agent wrote the code. I directed the system.