Right now, software teams are stuck in the hangover of the "tokenmaxxing" era—caught between AI hype that promised instant 10x velocity and a reality where senior engineers spend their days debugging sprawling, hallucinated slop.
Watching teams burn millions of tokens only to grind their velocity to a halt has made a lot of good engineers skeptical of agentic coding altogether. Set against that frustration, I have a potentially contrarian take: the hype is actually right: you practically never have to write code by hand again. And mourning the end of manual syntax typing makes about as much sense as mourning the end of hand-written Assembly when C compilers arrived.
The catch is that once you stop typing code yourself, you go from meticulously sculpting artisanal solutions to complex problems, to frantically trying to keep a swarm of agents from submitting nothing but incoherent slop. While you weren't looking, you involuntarily became a high school teacher.
Agents, like teenagers, will give you two different, contradictory answers five minutes apart with complete sincerity. Agents, like teenagers, might say something profound that makes you reconsider your life, right before opening the laundry cabinet and deciding to eat a Tide pod. Agents, like teenagers, can sometimes be remarkably productive, but you will be able to tell because of the incredible mess that trails behind them at all times.
AGENTIC LORD OF THE FLIES
Spend five minutes online and you'll hear a seductive promise: "Don't worry about architecture or clean code anymore—the agents will figure out how to organize things."
Having worked extensively with students with special needs, I have seen kids who can hand-solder a homebrew Z80-based computer, but also not be able to connect the fact that it's snowing outside with remembering to wear a jacket. When programmers watch an LLM one-shot a complex algorithm in three seconds, they fall for that exact same illusion: assuming that being able to solder the Z80 doesn't mean someone isn't still needed by the door to make sure the coat doesn't get forgotten.
"Drop a swarm of unsupervised agents onto a codebase and you don't get a self-organizing parliamentary democracy. You get Lord of the Flies."
For the first twenty minutes, they hold up the conch shell and write a very polite PLAN.md. But pretty soon, the signal fire is out, Piggy's glasses are smashed, and your repository is a 4,000-line monolith impaled on a pike.
By looking at agents like students with spiky cognitive profiles, I help teams redesign their codebases and reconsider their approach to working with agents—so they can actually get the velocity AI promised without spending their budgets in a week and the next months cleaning up the resulting slop.
// CASE STUDY: PUBLIC REPOSITORY BENCHMARKS
GREAT HUMAN CODE ≠ AGENT-READY CODE
What happens when you run generate_report_card.py against some of the most respected open-source Python, TypeScript, and JavaScript repositories in the world?
Frameworks like FastAPI, Flask, and Anthropic's official Model Context Protocol TypeScript SDK (mcp-ts-sdk) are world-class human codebases—and they score 100/100 (A+) on traditional human-era dimensions like type annotations, test assertion density, and naming clarity.
Where they get taxed is Agent Ergonomics. A human developer in VS Code can Cmd+Click to line 4,200 of fastapi/routing.py (6,553 lines) in zero milliseconds. An AI coding agent has to ingest ~65,000 tokens of context window just to read that single file—and without a CODEBASE_MAP.md or SCHEMA_DICTIONARY.md, it burns dozens of tool calls grepping the repo blind before it even gets there:
| Repository |
Stack |
Overall Grade |
Human Hygiene (Types & Tests) |
Where the Agent Loses the Plot |
| Async Academy Monorepo |
Python / JS |
A+ (100.0) |
A+ (161 suites · 100% autospec) |
0 files >1k lines · Full syllabus (AGENTS.md, CODEBASE_MAP.md, 19 ADRs) · 0 raw print() calls |
openai/swarm |
Python |
B+ (84.2) |
A+ (92% dense · 83% typed) |
0/100 on World-Model (no AGENTS.md / CODEBASE_MAP.md) · 10 raw print() calls in prod modules |
fastapi/fastapi |
Python |
B- (73.9) |
A+ (99% typed · 6,892 asserts) |
4 monoliths burning ~123,959 excess tokens/turn (routing.py at 6,553 lines, applications.py at 4,817 lines) · 130-line AST clone in websocket() · 17 un-specced patch() calls |
pallets/flask |
Python |
B- (71.3) |
A+ (99% typed · 1,028 asserts) |
3 monoliths >1k lines (app.py at 1,687 lines · ~21,017 excess tokens/turn) · 4 AST clone clusters (181 lines duplicated between blueprints.py & app.py) · 3 silent except: pass |
modelcontextprotocol/typescript-sdk |
TypeScript |
B- (70.3) |
A+ (90% typed · 13,137 asserts) |
Has CLAUDE.md (35/100), but taxed by 14 monoliths >1k lines (~206,567 excess tokens/turn), 128 raw console.log() calls, and 25 fetch() calls missing timeouts |
expressjs/express |
JavaScript |
C+ (67.0) |
F (33) naming/types · A+ tests |
Only 28% semantically-dense function names (get, set, use, fn, cb) & 0% type annotations · lib/response.js over 1,000 lines |
In the agentic era, a unified monorepo is table stakes—an LLM cannot reason across a dozen scattered repositories without hallucinating cross-service contracts. And you shouldn't have to risk production uptime while your team learns a new way of working.
Instead of trying to reform Jack's tribe while production is on fire, we never touch prod during the training. Over a 4-part, month-long sprint (four weekly half-day working sessions), your engineering team leaves Jack's camp behind and builds Ralph, Piggy, and Simon's camp from the ground up: standing up a brand-new, clean monorepo wired to an isolated agentic dev environment where the shelters are resilient, the signal fire stays lit, and you can actually see the plane on the horizon. At the end of the month, you walk away with a superior, production-ready parallel application—tested, codified, and agentically managed—that your team can cut over to for a "soft landing" completely at your own leisure.
01
WEEK 1
Self-Assessment Tools & The Test Blitz
Give Piggy his glasses back. LLMs aren't magic: they need good exemplars, descriptive feedback, and self-assessment tools so they can grade their own homework without mocking their own hallucinations. In Session 1, your whole team works simultaneously with agents for a single half-day blitz to build fast, strict in-memory mocks and critical-path E2E test suites, locking down expected behavior before migrating a single wire.
02
WEEK 2
The Parallel Monorepo & Isolated SSM Stacks
End tribal warfare across repos. Agents cannot reason about polyrepos or survive tightly coupled cross-stack deployment deadlocks. We stand up your clean, unified monorepo targeting an isolated agentic dev account—codifying strictly isolated microservice stacks decoupled via parameter stores, wiring up real agent test inboxes, and installing pre-deploy import and validation diagnostics so agents can deploy any service independently with zero blast radius.
03
WEEK 3
Protect the Context Window & Data Contracts
Post the rules of the island. Don't dump 50 random books on a teenager's desk. We curate your monorepo's syllabus so an agent never has to guess: generating a single-read codebase map and schema dictionary, enforcing strict thousand-line file ceilings, extracting static data into declarative manifests, and wiring up AST-based context packing and syntax-tree refactoring alongside hard cloud and LLM budget kill-switches.
04
WEEK 4
Socratic Red-Teaming
Keep the camp clean. With tests, IaC, and context maps locked in, we install your permanent agent instructions harness and flip how your team prompts—moving from imperative feature requests to open-ended, non-leading Socratic Red-Teaming that fights addition bias and sycophancy head-on:
"What is the worst part of this repo?",
"Does this solution represent a 'gold standard' implementation?",
"Were there any parts of this task that were particularly token-inefficient?", and the Developer Mirror prompt.