:root{–ink:#1a1a1a;–muted:#5b6470;–line:#e6e8ec;–accent:#2563eb;–accent2:#0d9488;–bg-soft:#f6f8fa;–amber:#b45309;}
*{box-sizing:border-box;}
.post{max-width:820px;margin:0 auto;padding:48px 22px 80px;
font-family:’Inter’,-apple-system,BlinkMacSystemFont,’Segoe UI’,Roboto,Helvetica,Arial,sans-serif;
color:var(–ink);line-height:1.68;font-size:18px;-webkit-font-smoothing:antialiased;}
.post .kicker{font-size:13px;letter-spacing:.14em;text-transform:uppercase;color:var(–accent);font-weight:700;margin:0 0 14px;}
.post h1{font-size:2.55rem;line-height:1.12;font-weight:800;letter-spacing:-.02em;margin:0 0 18px;}
.post .dek{font-size:1.28rem;line-height:1.5;color:var(–muted);font-weight:400;margin:0 0 28px;}
.post .byline{font-size:14px;color:var(–muted);border-top:1px solid var(–line);border-bottom:1px solid var(–line);padding:12px 0;margin:0 0 36px;}
.post h2{font-size:1.62rem;font-weight:750;letter-spacing:-.01em;margin:52px 0 14px;padding-top:6px;}
.post h3{font-size:1.22rem;font-weight:700;margin:34px 0 10px;}
.post p{margin:0 0 20px;}
.post a{color:var(–accent);text-decoration:none;}
.post a:hover{text-decoration:underline;}
.post strong{font-weight:700;}
.post .lede:first-letter{font-size:3.2rem;line-height:.8;font-weight:800;float:left;margin:6px 12px 0 0;color:var(–ink);}
.post blockquote{margin:30px 0;padding:6px 0 6px 24px;border-left:4px solid var(–accent);
font-size:1.32rem;line-height:1.45;font-weight:600;color:#0f172a;font-style:normal;}
.post blockquote cite{display:block;margin-top:8px;font-size:.95rem;font-weight:500;color:var(–muted);font-style:normal;}
.post .tldr{background:linear-gradient(135deg,#f0f6ff,#effcf7);border:1px solid #dbe7ff;border-radius:14px;padding:22px 26px;margin:0 0 40px;}
.post .tldr h4{margin:0 0 12px;font-size:13px;letter-spacing:.12em;text-transform:uppercase;color:var(–accent);}
.post .tldr ul{margin:0;padding-left:20px;}
.post .tldr li{margin:0 0 8px;font-size:1.02rem;}
.post .callout{background:var(–bg-soft);border:1px solid var(–line);border-left:4px solid var(–accent2);border-radius:10px;padding:18px 22px;margin:28px 0;}
.post .callout h4{margin:0 0 8px;font-size:12px;letter-spacing:.1em;text-transform:uppercase;color:var(–accent2);font-weight:700;}
.post .callout p:last-child{margin-bottom:0;}
.post .warn{border-left-color:var(–amber);}
.post .warn h4{color:var(–amber);}
.post .statband{display:grid;grid-template-columns:repeat(3,1fr);gap:14px;margin:34px 0;text-align:center;}
.post .statband .num{font-size:2.3rem;font-weight:800;letter-spacing:-.02em;color:var(–accent);line-height:1.05;}
.post .statband .lab{font-size:.86rem;color:var(–muted);margin-top:4px;}
.post table{width:100%;border-collapse:collapse;font-size:.96rem;margin:26px 0;}
.post th,.post td{border:1px solid var(–line);padding:10px 12px;text-align:left;vertical-align:top;}
.post th{background:var(–bg-soft);font-weight:700;}
.post code{font-family:’SFMono-Regular’,Menlo,Consolas,monospace;background:var(–bg-soft);border:1px solid var(–line);border-radius:5px;padding:1px 6px;font-size:.88em;}
.post pre{background:#0f172a;color:#e2e8f0;border-radius:10px;padding:18px 20px;overflow-x:auto;font-size:.9rem;line-height:1.55;margin:26px 0;}
.post pre code{background:none;border:none;color:inherit;padding:0;}
.post hr{border:0;border-top:1px solid var(–line);margin:44px 0;}
.post sup a{color:var(–accent);font-weight:600;font-size:.72em;text-decoration:none;padding:0 1px;}
.post .references{margin-top:56px;padding-top:28px;border-top:2px solid var(–line);font-size:.9rem;}
.post .references h2{font-size:1.3rem;margin-bottom:14px;}
.post .references ol{padding-left:0;list-style:none;counter-reset:ref;}
.post .references li{counter-increment:ref;position:relative;padding-left:34px;margin-bottom:12px;color:#3b4453;line-height:1.5;}
.post .references li::before{content:”[“counter(ref)”]”;position:absolute;left:0;font-weight:700;color:var(–muted);}
.post .cta{background:linear-gradient(135deg,#eff6ff,#ecfdf5);border:1px solid #d7e6ff;border-radius:14px;padding:24px 26px;margin:40px 0 8px;}
.post .cta h4{margin:0 0 10px;font-size:1.15rem;}
@media(max-width:600px){.post{font-size:17px;padding:32px 18px 60px;}.post h1{font-size:2rem;}.post .statband{grid-template-columns:1fr;}}

The AI Operating Model

How to Do a Month’s Work in 1 Day

The upgrade wasn’t the model. It was giving up the keyboard and learning to run a small, adversarial, cost-aware org of agents — at high effort, not max, and bounded so tightly that letting it rip was the safe choice.

A practitioner field guide for engineers and engineering leaders who already use AI coding agents — and are leaving most of the leverage on the table.

Picture a project that has quietly stalled for a month. Twenty or thirty pull requests, each 50–80% finished, none of them moving. Good ideas that never shipped. The kind of backlog that makes you avoid the repo. Then, in a single autonomous session of roughly five and a half hours — most of it watched from a phone — the whole graveyard clears. PRs triaged, dead ones closed, survivors rebased and merged, the rest re-specced and rebuilt. A month of roadmap, shipped in a day, for about 150 dollars all-in.

That’s the experience Theo Browne (t3.gg) documented on his project Lakebed with a top-tier coding model driving Claude Code. The temptation is to file it under “the model got smarter.” That’s the wrong lesson — and the most expensive one you can learn, because it tells you to keep doing exactly what you’re doing, just harder.

“This model isn’t a better Opus. The difference isn’t how much smarter it is — it’s how much further it can go: end-to-end implementation, testing, verifying, and breaking work up to hand off to sub-agents.”
— Theo Browne (t3.gg), source video

Read that twice. The gain isn’t a taller IQ. It’s range. And range only pays off if you get out of the way. The month-in-a-day number doesn’t come from the model delta; it comes from removing the human bottleneck — you, prompting one task at a time, at max effort, watching every diff. This piece is about the operating model that replaces that habit.

The wrong lesson vs the real leap

For five years we learned to manage models like fast, dim executors. You held the intelligence; the prompt was a spec you handed down; you checked everything. That was correct — for GPT-3 and early GPT-4. Import those habits onto a model that can carry a task end-to-end and delegate, and you cap it at the old ceiling. Anthropic’s own production research system is built the other way: a lead agent that “coordinates the process while delegating to specialized subagents that operate in parallel.”¹ The org, not the oracle, is the unit of work.

So the reframe is a role change:

The org chart: a lead with taste, and a bench picked by task shape

Start with staffing. One high-intelligence, high-taste model is the orchestrator: it plans, decomposes, and delegates. It dispatches cheaper, faster, “good-enough” models for bulk, mechanical, and token-hungry work — log digging, huge PDFs, computer use, hundreds of screenshots — and reads back only the compressed result. This is the orchestrator-worker pattern Anthropic ships, where subagents “operate in parallel with their own context windows… before condensing the most important tokens for the lead.”¹

The important move is how you choose who does what. Not by prestige — by the shape of the task. The smartest model isn’t the right model for every job; it’s the right model for judgment and taste. Everything else is cheaper to explore with a near-free model and escalate only if the output misses the bar. Cost-aware routing research bears this out bluntly: send each request to the cheapest model that can handle it and teams “report bill reductions in the 40–85% range… without a visible drop in answer quality — because most production traffic never needed a frontier model in the first place.”⁹ RouteLLM hit “95% of GPT-4’s performance while using GPT-4 for only 14% of queries.”¹⁰

The glossary: the one config page that matters

Here’s the artefact to actually build. In your agent config (CLAUDE.md, AGENTS.md, whatever your harness reads), the highest-leverage thing you can write is not a list of rules. It’s a glossary: your axes for choosing models, and — critically — the definitions of your words. Theo scored his bench on three axes he cared about — cost, intelligence, taste — and then told the model what those words mean:

# Picking the right models for workflows and subagents
# Rankings, higher = better. (Theo's personal rubric — his stated
# experience, not a benchmark. Generalise the shape, not the scores.)

model      cost  intelligence  taste
gpt-5.5      9        8          5
sonnet-5     5        7          8
opus-4.8     4        8          7
fable-5      2        9          9

# intelligence = the hardest problem you can hand it unsupervised
# taste        = UI/UX, code quality, API design, copy

# These are DEFAULTS, not limits. Standing permission to escalate:
# if a cheaper model's output misses the bar, redo it with a smarter
# one without asking. Judge the output, not the price tag —
# escalating costs less than shipping mediocre work.

Two things make this work. First, the definitions: “intelligence” and “taste” mean nothing to a model until you say what they mean to you. Second, the policy — defaults, not limits. That escalation clause is the routing-research “cascade” pattern in plain English: start cheap, climb only when a cheaper tier fails.¹⁰ It’s what stops you from cost-optimising your way into mediocrity.

Judge the output, not the price tag. Escalating costs less than shipping mediocre work.
— from the model-selection rubric

Two tools, two jobs: sub-agents vs workflows

With the bench staffed, you need two coordination primitives, and they’re not the same thing.

Sub-agents are fan-out: spawn N agents, one per item — one analyst per file, one investigator per PR — all at once. Workflows are pipelines: a programmatic script with stages and conditional gates, where the output of stage one decides what stage two does (“investigate each PR; if flagged, route it to two more reviewers”). Reach for fan-out when the work is parallel; reach for a workflow when it’s checkpoint-driven.

When Theo asked the model to “investigate and review the open PRs,” it wrote itself a workflow and reported back:

“All 48 agents finished: 16 investigators (one per PR), each verdict then stress-tested by a Fable + Opus judge panel. 14 of 16 calls were unanimous; I resolved the two contested ones.”
— Theo Browne (t3.gg), source video

Notice what you didn’t have to do: define the reviewer archetypes. The old advice was to hand-build “a review sub-agent, an adversarial sub-agent, an exploratory sub-agent.” A frontier model now invents the archetypes the specific task needs. Your job is to demand review, not to script it.

The battle of the AIs: quality by independent adversaries

This is the part that converts “the model merged its own code” from reckless to rigorous. No single model certifies its own work. Quality comes from a jury of independent reviewers cross-checking each other: a judge panel of different models (a Fable + Opus panel), plus external review bots (Bugbot, Macroscope, CodeRabbit), plus an outside-vendor perspective (GPT-5.5/Codex). The merge gate is explicit: do not merge until the automated reviewers approve.

The reason it has to be independent — not the same model twice — is correlated blind spots. As CodeRabbit puts it, “models from the same family tend to share the same blind spots,”⁴ which is exactly why an ensemble beats a single reviewer. Field tests of parallel review bots agree: “No pair dominates. No two reviewers are twins… They are genuinely seeing different things.”⁴ And the academic case is the same — panels with “possibly adversarial roles… achieve higher reliability and closer alignment to human consensus than a lone model,”³ because “an error that one agent overlooks might be caught by another.”³

Run at high, not max — the point everyone gets wrong

Here’s the counter-intuitive core, and it’s worth resisting the instinct to soften it. Do not run your model at the highest reasoning tier. The xhigh/max/ultra settings look irresistible — “the fancy gradient… like a slot machine begging you to put another coin in” — and they will hand you worse code at higher cost.

“High is smarter. I know that sounds like a mistake — it isn’t. xhigh and max second-guess themselves; they reason in longer and longer loops and hand you worse, overdone code with way too many changes for the simple thing you asked, at an absurdly higher cost.”
— Theo Browne (t3.gg), source video

The mechanism is the part to internalise: reasoning effort is per-tool-call, not per job. It does not determine how long the model can work — only how hard it thinks on each individual step. If a task takes 500 steps, max doesn’t take more steps; it thinks harder on every one, and most steps don’t need it. So you pay a premium to have simple changes over-engineered.

This isn’t one person’s vibe. 2025 research documents “overthinking”: extending test-time thinking “initially boosts model accuracy, but performance degrades subsequently with prolonged thinking,”⁵ a non-monotonic curve where more tokens can lower quality. The cost side is just as stark — one study ran the same agent at high effort for a 29.1% resolution rate at $1,400, versus 21.0% at $400 for low, and found that generating two low-effort solutions and picking the better one “nearly matches the performance of high-reasoning configurations while reducing computational costs by 43%.”⁶ Vendor docs price the top tier at “10x+ token usage vs low.”⁷ Effort is a dial to tune, not to max.

The other half of the cost story is routing. The expensive part of most work is reading, not deciding — logs, giant PDFs, screenshots, computer use. Route that to a near-free model and report the findings up; spend your frontier tokens on judgment. Between running at high and routing the token-hungry work down, the whole month of Lakebed work came in around $150, with neither subscription past 40% usage. One setting change — high instead of max — “can cut your bill by half or more.”

Goals, worktrees, and the guardrail that makes autonomy sane

Now the autonomy. You stop writing prompts and start setting goals: “keep going until every box is done; you may branch, rebase, merge, and close PRs.” You write the plan to a TODO.md, hand over standing permission, and let it run. Theo’s ran for five hours: “every time I checked GitHub on my phone, more code had landed.” This mirrors how OpenAI describes long-horizon Codex runs — a durable “spec, plan, constraints, and status in markdown files” plus continuous verification, the direction being “less babysitting, more delegation with guardrails.”¹³ And it’s feasible now because the task horizon models can sustain has been “growing exponentially… with a doubling time of approximately seven months.”¹²

Parallelism runs on git worktrees — each agent gets its own checked-out directory over a shared object store, so their edits can’t collide. Worktrees are now “the dominant isolation primitive for running multiple AI coding agents in parallel,”⁸ and usefully, they “defer the conflict problem to the PR merge stage”⁸ — which is exactly where your adversarial review gate already sits. You can spin up a throwaway worktree per idea or bug from anywhere, even your phone.

But none of this is sane without the envelope. Here’s the load-bearing fact:

“Production deployments are still a human in the loop. This is just the staging deployments that happen when you merge to main. The model cannot ship or touch prod — it can use staging for basically whatever it wants.”
— Theo Browne (t3.gg), source video

This is why AI-assisted coding is such a clean lane in the first place: code → PR review → CI/CD → rollback routes every change through governance you already have. The industry consensus on autonomous pipelines lands in the same place — “AI agents can move quickly in lower-risk environments, but anything that can materially impact… production should pass through human review.”¹⁵ Not no humans. No surprises.

Verification is now the expensive half

When producing work becomes cheap, checking it becomes the job. Theo’s own accounting is the tell:

“I burned way more tokens verifying the work than getting it done. There was nothing to change — which means I’m not pushing hard enough.”
— Theo Browne (t3.gg), source video

That instinct is now a law. Jason Wei’s “verifier’s rule” holds that “the ease of training AI to solve a task is proportional to how verifiable the task is,”¹¹ which makes verification the scaling lever — and the human’s new center of gravity. In practice it means spinning up fresh agents to stress-test old and new features, diffing prod against main, and de-risking, sometimes on other machines. The practitioner framing is exactly right: you “have other people tasked with breaking the product and hunting for bugs.”¹¹ If nothing needs fixing, you’re not pushing hard enough.

Read the clock: time-to-solve as an architecture smell test

One more instrument, almost free. The time an agent takes to solve something is a probe you can read your codebase’s health off:

A back-navigation bug fixed in two minutes twenty; a scroll-jump bug that took over an hour and a half and set off alarms. Same agent — the effort it expends is a sensor for where the good and bad parts of your codebase live. The amount of time and the number of files it has to touch tells you more than the diff itself.

Make it yours — and take it everywhere

The last piece is the human skill that makes all of it stick. Skills and configs aren’t a setup you copy from an expert; they’re a living document you grow from your own pain. A skill is just a description plus a body it loads on demand — write the fix the first time something goes wrong, then halve it and paste it in. Don’t blind-copy someone else’s config: “Do it. Learn it. Change it.” And talk to your agents — ask questions to align before you commit, and remember that “your call” is a valid answer to hand back.

Everything here generalises past code, because the operating model is domain-agnostic. A content pipeline: orchestrator plus specialist drafters, an adversarial editor-and-fact-checker panel, batched overnight, shipping reviewable artefacts. A research workflow: cheap scouts gather, the frontier model judges, a jury cross-checks the conclusion. Back-office automation: goal-loops in a sandboxed lane, human-gated on anything irreversible. Same artefacts every time — glossary → org → gates → goal → blast radius → verification. If the work is batchable, reviewable, and cage-able, it’s a clean lane. Batch the brain, ship the artefacts, govern like software.