The Mythical Agent-Month

Wes McKinney (creator of pandas, Apache Arrow, Ibis) applies Fred Brooks's 1975 classic The Mythical Man-Month to the age of AI coding agents. The core argument: agents are the most powerful tool ever created for tackling accidental complexity — but they generate new accidental complexity that obscures the essential structure. He burns 10 billion tokens/month across Claude, Codex, and Gemini, doesn't write code by hand anymore, and still gets out of bed at 5am because the hard part was never the typing.

Key Quotes

"Agents are so good at attacking accidental complexity, that they generate new accidental complexity that can get in the way of the essential structure that you are trying to build."

"When generating code is free, knowing when to say 'no' is your last defense."

"The accidental complexity is no problem at all anymore, but what's left is the essential complexity which was always the hard part. Agents can't reliably tell the difference."

"Every new change has to hack through the code jungle created by prior agents. Call it a 'brownfield barrier.'"

"We can 'type' 10x, maybe 100x faster with agents than we could before. But we still have to make good design decisions, say no to most product ideas, maintain conceptual integrity, and know when something is 'done'."

"The developers who thrive in this new agentic era won't be the ones who run the most parallel sessions or burn the most tokens. They'll be the ones who are able to hold their projects' conceptual models in their mind, who are shrewd about what to build and what to leave out, and exercise taste over the enormous volume of output."

"The median software consulting shop is completely toast."

"I've largely stopped fighting it: now when I'm rolling around restlessly in bed at 5:07am with ideas to feed my AI coding agents, I just get up and start my day."

The Brooks Framework

McKinney works through three of Brooks's arguments and maps each onto agentic development:

Conceptual Integrity

Brooks argued small elite teams with a "chief surgeon" outperform large teams — one mind designs, many hands build. Agentic engineering amplifies this: software quality is now only as good as the humans in the loop curating specs, saying no, and taming unnecessary complexity. The chief surgeon model becomes literal — you're the only mind in the loop.

The Tar Pit → Agentic Tar Pit

Brooks's tar pit metaphor (beasts struggling, each looks like it could escape, but the tar holds them all) gets an update: parallel Claude Code sessions and git worktrees are now "engaged in combat with the code bloat and incidental complexity generated by their virtual colleagues." You can refactor, but agentic codebases invariably end up larger and more overwrought than anything built by human hand. Technical debt at machine speed.

The 1/9th Rule

Brooks observed a working program is maybe 1/9th of a programming product (tested, documented, hardened, maintainable). Agents make the "appears-to-work" program vastly more accessible, but new AI vibe coders underestimate the prototype-to-production gap. This connects to Cognitive Debt — the code exists, but nobody understands it.

Conway's Law + n(n-1)/2

What does Conway's Law mean for a virtual "team" of agents with no persistent memory and no shared understanding? The coordination problem doesn't disappear — it changes shape. Different agent sessions produce contradictory plans humans must reconcile. McKinney flags this as a topic for another post (see Agent Orchestration, Zero Alignment).

No Silver Bullet: Essential vs. Accidental Complexity

This is the intellectual core of the piece, and it was entirely missing from the earlier version of this page.

Brooks's 1986 follow-up essay distinguished essential complexity (fundamental to the problem — make it any simpler and it stops solving the problem) from accidental complexity (everything imposed by tools, languages, processes, and the need to make systems understandable to other engineers).

McKinney's application:

• Agents obliterate accidental complexity. He writes Go without having ever learned it. He doesn't write code anymore. He wonders whether IDEs will be relevant in two years when a text editor to review diffs might suffice. 10 billion tokens/month is the scale.

• But essential complexity remains. LLMs are pattern matchers trained on open source — brilliant at "refactor this, write these tests, clean up this mess" but lost on novel design problems with no precedent to pattern match against. They generate defensive boilerplate rarely needed in practice.

• The paradox: agents are so good at attacking accidental complexity that they create new accidental complexity which gets in the way of essential structure. It's a self-defeating loop.

The Brownfield Barrier

At ~100 KLOC (roborev, msgvault), agents begin chasing their own tails and choking on the bloat they generated. At 1M+ lines (Positron, a VSCode fork at Posit), they struggle hard. McKinney calls this the "brownfield barrier" — the point where agent-generated code becomes so thick that further agent work degrades rather than improves the system.

He won't bet on whether this is a ceiling or a plateau. Models are improving fast. But Brooks's essential/accidental distinction gives him confidence this isn't just about current model limitations. "Figuring out what to build was the hard part long before we had LLMs, and I don't see how a flawless coding agent changes that."

Agentic Scope Creep

A dedicated section with its own thesis: zero-cost code generation destroys the natural braking mechanism on feature growth.

The dynamic: "and now can you just…?" becomes irresistible when each addition costs nothing to generate. But every new feature carries a future contextual burden for subsequent agent sessions. What seems free now is a tax on every future change.

McKinney extends this to open source: projects are "drowning in torrents of 3000-line 'helpful' PRs." The submitter didn't write or fully read the code — nobody is accountable for the design decisions. This connects directly to I Don't Want Your PRs Anymore.

On his own projects: agents propose overwrought solutions when simple ones would do. It takes judgment to intervene and keep the agent in check. This is the same discipline as Slowing the Fuck Down and Code Field — resisting the urge to let generation velocity substitute for design judgment.

Design and Taste as the Last Foothold

McKinney's closing thesis: Brooks argued design talent is the scarcest resource. With agents handling all coding labor, taste matters more, not less. The bottleneck was never hands on keyboards.

Who thrives: not the highest token burners, but those who can hold their project's conceptual model in their mind, who are shrewd about what to build and leave out, and who exercise taste over enormous output volume.

He draws a sharp distinction: not all software is equal. CRUD business apps ≠ databases and systems software. The median consulting shop is "completely toast." But the 1% tail — problems inaccessible to most engineers — still requires expert humans in the loop. His example: Alex Lupsasca at OpenAI working with world-class physicists to formulate and solve hard physics problems with AI help. Without such experts, LLMs couldn't pose the questions, let alone find the answers.

The essay closes with the 5am ritual — feeding and taming agents before dawn. "The coding is easier now, and honestly more fun, and I can spend my time thinking about what to build rather than wrestling with the tools and systems around the engineering process."

Critical Analysis

The Brooks analogy is apt but incomplete in ways McKinney himself acknowledges. Brooks argued adding people to a late project makes it later because of communication overhead. McKinney argues adding agent output to a large codebase makes it worse because of complexity overhead. The crucial difference: you can refactor a codebase in ways you can't reduce human communication overhead. Whether tools like workgraph, Three Tier Memory, and disciplined spec practices can push the brownfield barrier further out is an open question — nobody has demonstrated it at 1M+ scale.

McKinney's most original contribution is the essential/accidental paradox: agents don't just fail to solve essential complexity (that was always the human's job) — they actively create new accidental complexity that makes the essential structure harder to see. This is a more precise formulation than the usual "agents generate slop" critique. It's not about code quality; it's about the relationship between generated surface area and design legibility.

His 1% thesis is worth watching. If he's right, the economic split won't be "AI replaces developers" but "AI replaces the median, while the tail becomes more valuable." The consulting-shop-is-toast line is the most provocative claim in the piece — and the one most likely to be tested in the next 18 months.

The piece is also notable for what it rejects: "vibe coding" as a pejorative, the "prompt and chill" aesthetic. McKinney builds roborev specifically to bring rigor and continuous supervision to parallel agent sessions. He's doing Compound Engineering whether he uses that term or not.

Reviewed by Martin Blais, Josh Bloom, Phillip Cloud, Jacques Nadeau, and Dan Shapiro — a serious reviewer list that signals this isn't a hot take but a considered argument from someone deep in the infrastructure.

Sources: The Mythical Agent-Month Last updated: 2026-05-18