Maximum Output
with Claude Code
A developer's field guide to running AI like a system, not a chat box - persistent context, planning gates, controlled execution, and verification.
↓ scroll to read · P prints the full guide · click the pipeline rail to jump
Same model. 10× the output.
Everyone here already uses AI. Output still varies wildly between developers - same tool, same plan, same model. The difference is the operating system you build around the model: context, session discipline, a research-first planning gate, and human verification.
One principle drives the whole workflow: errors get more expensive the later you catch them. Every step in this deck exists to push decisions earlier - where they're cheap - and every step names the exact cost of skipping it.
Cost of catching the same mistake at each phase.
Eight stages. Two human gates.
highlighted = human gate. Everything else can be delegated to the agent. These two cannot - and most AI-assisted failures trace back to treating one of them as optional.
The next nine slides walk the pipeline left to right. Each one ends with the same box: what the step saves you from.
The repo's brain: CLAUDE.md
An agent without context is a very fast intern with amnesia. Claude Code auto-loads CLAUDE.md into every session - so the project's brain goes into a file once, not into prompts forever. Committed to git: every developer's agent gets it.
- 10-second summary - what this repo is, and is not
- Architecture map - where things live
- Exact commands - build · test · lint · run. Never let it guess pytest vs npm test
- Conventions - naming, errors, logging, "we use X, not Y"
- Git rules - branches, commit format, PR checklist
- Known gotchas + pointers to docs/ai-context/
$ /init
# link out to detail docs, don't paste them
# provider-agnostic - same brain for Cursor/Codex/Gemini:
$ ln -s CLAUDE.md AGENTS.md
Every line is context spent before work begins. Lean file, linked depth.
Re-explaining the repo every session (10 min × every dev × every day). Wrong build commands. Five teammates getting five different conventions from the same model. New joiners' agents starting from zero.
Personal layer + depth on demand
Your private layer
User-level memory, loads in all your projects on top of the repo file: response style ("direct, no fluff, ask before assuming"), personal workflow rules, machine paths. Project-personal notes that don't belong in git go to local memory files - not the shared file.
Depth on demand
Deep docs the agent reads when a task needs them: architecture decision records, domain vocabulary, API contracts, integration quirks. CLAUDE.md stays lean; depth stays one read away. Exactly the pattern we already run in production.
Restating your preferences every session. The team file turning into one developer's diary. And the 600-line CLAUDE.md that eats half the context window before the task even starts.
One session = one task, named at birth
> /rename # or (auto-)name it later
> /model · /effort # firepower to match the task
> /context # where is the window going?
> /clear # new task = clean slate
$ claude -r "payment-webhook-retry" # a month later
One task per session
The window is the agent's working memory. Mix three tasks and all three reason over each other's leftovers - quality drops, tokens burn re-reading files.
Name it, resume it
A named session keeps everything - files read, decisions, your corrections. Resuming costs near zero; restarting re-pays the whole exploration bill.
Right effort per task
Planning and review deserve max reasoning; renaming a variable doesn't. Strongest model + high effort for design - faster model for mechanical edits.
Paying twice to re-read the same files. Yesterday's refactor leaking into today's hotfix. "What was I doing?" archaeology. Token bills you can't explain.
Research-first planning
Plan mode (Shift+Tab · /plan) makes the session read-only - the agent can explore the codebase and the web but can't touch files. Then the key move, asked explicitly:
for <problem> online before proposing anything. Cite sources.
Then write the plan."
- Training data ages from day one - your dependencies don't stop moving
- Surfaces today's recommended API, next month's deprecation, the library that already solved it - with citations, in minutes
- A human doing the same: ~2 hours of skimming, and still misses things
Make it repeatable
Workflow plugins - superpowers, compound-engineering - turn brainstorm → research → plan → execute into a process instead of a mood. Install once; the discipline stops depending on how well you prompt today.
Building on deprecated APIs. Reinventing a problem solved last quarter. Plans based on 2024 memory in a 2026 codebase. And the most expensive failure of all: confidently implementing the wrong approach.
The visual plan gate
A 400-line plan as terminal text invites skimming - and skimmed approval is no approval. Before any code:
phases, architecture & sequence diagrams, file-touch map, the
reasoning behind each decision, risks and rollback."
Review it phase by phase like a design doc. Push back. Massage steps to fit the real requirement. Regenerate. Approve only when you'd defend every phase in code review. This is the cheapest moment in the entire lifecycle to change direction - and the page doubles as the design doc you attach to the PR.
Rubber-stamping a wall of text. Design flaws discovered mid-implementation at 10× the fix cost. "That's not what I meant" after 2,000 lines. Writing the design doc twice.
Build with subagents
Delegate implementation to subagents - isolated workers with their own context window, prompt and tool permissions (built-ins like Explore, custom ones in .claude/agents/). The main session stays the orchestrator: it holds the plan and your decisions; subagents burn their own context reading files and return distilled results.
Work lands in slices
One plan phase at a time - never the whole feature in one shot.
You review each slice
While it's still small enough to actually read. Confirm, then release the next phase.
Checkpoints
Approach went sideways? Roll code and conversation back together.
Main-thread context bloat - reasoning quality decays as the window fills. One giant 2,000-line unreviewable diff at the end. The "agent ran 40 minutes unsupervised" surprise.
Manual testing + bug documentation
Tests passing, types checking, lint clean - that means the code agrees with itself, nothing more. The agent verifies what it can see; you verify what users feel. Run the feature in a real environment. Push the edge cases that come from knowing the business.
Found a bug? Fix it in-session while context is warm. Then the step almost everyone skips: document the bug class and feed it back into CLAUDE.md or docs/ai-context/ - "always handle timezone-naive datetimes at API boundaries." Every bug becomes a permanent rule the agent follows in all future sessions. That is the difference between a workflow that compounds and one that plateaus.
"Tests pass, feature broken." Agent-written tests that only prove the agent's code agrees with itself. Paying for the same class of bug twice - or five times, across teammates.
One bug, one permanent rule
Manual testing on the timezone example from the previous slide turns up a real bug: a datetime crossing midnight UTC compares wrong against a naive local timestamp. Fixed in-session - then the rule goes into CLAUDE.md so no future session repeats it.
The same bug class resurfacing in the next PR, written by the same agent, because nothing told it the rule changed. One sentence, committed once, applies to every session after - yours and every teammate's.
Commits with intent
Group the work into logical commits - one concern each: schema change, business logic, tests, docs. The agent drafts messages from the actual diff (it read every line; its summaries are honest). You do the final read before push.
History is a debugging tool. A clean one is the difference between git revert and a 2 a.m. manual unpick.
"final-fix-2-really" archaeology. Un-bisectable, un-revertable history. Reviewers forced to untangle five concerns inside one commit.
Machine review, then human review
/code-review · /security-review
On the branch - or a Claude review wired into CI so every PR gets it automatically. Catches correctness bugs, security slips and convention drift before a human spends a minute.
Judge the design, not the nits
With nits pre-cleared, humans do what only humans can: is this the right design? Does it actually solve the ticket? Will ops hate us in six months?
Senior engineers spending review time on formatting. Security issues a bot catches in seconds. Review fatigue - the silent killer that turns "LGTM" into a rubber stamp.
Beyond the core loop
Custom slash commands
A prompt you've written twice becomes a command: /fix-issue 123, /plan-html. Whole workflows in one keystroke, identical for the whole team.
Hooks + deny rules
Deterministic guardrails: block destructive commands, auto-format after every edit. Unlike instructions, these always execute - the model can't "forget" them.
Real data, not paraphrase
Wire Jira, Sentry, your DB, Figma. The agent reads the real ticket, the real stack trace, the real schema.
Packaged know-how
Deploy runbook, review checklist, domain rules - written once, every developer's agent gains the capability.
True parallelism
Multiple named sessions on separate branches simultaneously. Zero collision, full speed.
Fearless experiments
Roll code and conversation back together when an approach dies. Checkpoints make boldness cheap.
What kills the gains
- ✕One mega-session for everything. Context soup - quality decays as the window fills, and you pay twice: tokens and bugs.
- ✕"Just write the code," zero context. You saved ten minutes of setup and will spend two hours steering and debugging. GIGO is arithmetic, not a slogan.
- ✕Skipping plan review because it "looks long." You'll read it anyway - as a diff, at 7 p.m., line by line, deadline closer.
- ✕Treating "all tests pass" as proof. The agent's tests prove the agent's code agrees with itself. Run the feature.
- ✕Auto-accept as a lifestyle. Fine inside an approved plan. As a default, you're not reviewing - you're spectating.
- ✕Letting CLAUDE.md rot. The agent follows stale rules confidently. Wrong context is worse than no context - review memory files in PRs, like code.
The whole system
| STAGE | MOVE | WHERE / COMMAND | WHAT IT SAVES |
|---|---|---|---|
| CONTEXT | Repo brain, committed | CLAUDE.md (+AGENTS.md) · /init → prune | Re-explaining repo · wrong commands |
| CONTEXT | Private layer · deep docs | ~/.claude/CLAUDE.md · docs/ai-context/ | Restating style · bloated CLAUDE.md |
| SESSION | Name · one task · resume | claude -n · /clear · claude -r "name" | Contamination · re-paying exploration |
| SESSION | Right firepower | /model · /effort · /context | Overpaying easy, underthinking hard |
| RESEARCH | Read-only + research | /plan + "research first, cite sources" | Deprecated APIs · wrong approach |
| PLAN GATE | Visual plan review | "plan as local HTML" → massage → approve | Design flaws at 10× fix cost |
| BUILD | Subagents · phase diffs | .claude/agents/ · git diff · /rewind | Context bloat · mega-diffs |
| TEST | Manual run · document bugs | feed rules back into CLAUDE.md | Repeating the same bug class |
| COMMIT | Logical groups | agent drafts · final human check | Unrevertable history |
| REVIEW | Machine pass, then human | /code-review · /security-review · CI | Nits eating senior review time |
| GUARDRAILS | Deterministic rules | .claude/settings.json - hooks, deny | Instructions the model "forgets" |
One real ticket, start to finish
Same bug as the example two slides back, run through the full pipeline. Nothing here is exotic - it's the eight stages, in order, on a ticket small enough to fit a coffee break.
- Session1 min
Named fix-timezone-bug, fresh context - nothing left over from yesterday's refactor.
- Research4 min
Plan mode surfaces that pytz is in maintenance mode and the standard-library zoneinfo is the current recommendation - cited, not remembered.
- Plan gate3 min
Visual HTML plan flags one wrong assumption - it assumed all timestamps arrive UTC-aware. Pushed back, regenerated, approved.
- Build12 min
Two subagent phases: normalize-at-boundary helper, then call-site updates. Each diff reviewed before the next phase starts.
- Test6 min
Manual run catches the midnight-UTC edge case the agent's own tests didn't. Fixed in-session, rule fed back into CLAUDE.md (previous slide).
- Commit + review4 min
Two logical commits - helper, then call sites. Machine review clean; human review checks the design, not the formatting.
≈ 30 minutes · two human checkpoints · one bug class that can never recur.
Do this once. Then run one real ticket.
- 10 MIN/init in your repo → prune CLAUDE.md to ~120 lines → commit. Mirror as AGENTS.md.
- 5 MINWrite ~/.claude/CLAUDE.md with your personal preferences and rules.
- 5 MINCreate docs/ai-context/ with the one architecture doc you explain most often.
- 5 MINAdd permission deny rules for destructive commands to .claude/settings.json.
- 5 MINInstall workflow plugins (superpowers / compound-engineering) via /plugin.
Honest expectation: the first full run feels slow - you're paying setup cost. The second feels normal. By the fifth, going back to "just write the code" feels reckless, because now you can see what each skipped step costs.
Docs: docs.claude.com/en/docs/claude-code - commands verified June 2026, Claude Code 2.x · Workflow & field notes: Anupam Kumar