Most teams building AI agents spend months writing thousands of lines of fragile orchestration code, treating the framework as the brain. Meanwhile, top engineering teams are shipping production-grade systems in roughly 200 lines of harness code—moving all domain intelligence into decoupled, modular skill files.
The 10,000-Line Orchestration Trap
When developers build autonomous systems, their default instinct is to write monolithic Python state machines, deep inheritance trees, and brittle routing logic. They believe the orchestration framework must handle every edge case, retry loop, and validation check. In practice, this creates heavy, high-latency middleware that cripples performance. Consider tool execution: Garry Tan demonstrated a staggering 75× performance gap between a direct Playwright CLI and a bloated Chrome MCP layer (Source: Garry Tan / YC). The root problem is not model intelligence—it is harness obesity. When your harness tries to think, it slows down execution, obfuscates debugging, and locks domain expertise behind software deployments.
The Operating System Analogy
To build resilient autonomous systems, reframe your architecture: the harness is just the CPU kernel, while skills are user-space executables. A computer operating system does not hardcode how video editing or spreadsheets work; it merely provides I/O, manages memory, and executes instructions. A thin harness should do nothing more than read user input, load the necessary context, call the model, and execute standard CLI tools or scripts. Multiple technical sources demonstrate that an optimal CLI harness needs only about 200 lines of code (Source: Garry Tan / GStack). All procedural judgment, business rules, and error-recovery behaviors belong in 'fat skills'—declarative markdown and isolated deterministic scripts.
The CORE Agent Architecture
To implement this separation cleanly, use the CORE Framework (Context, Operations, Runtime, Evaluation). This four-part system isolates system mechanics from procedural intelligence:
- C - Context Injection: Dynamic loading of declarative markdown rules into the system prompt per task.
- O - Operations (Fat Skills): Self-contained tool definitions, validation checklists, and execution guides.
- R - Runtime (Thin Harness): A minimal 200-line loop handling raw model I/O and subprocess execution.
- E - Evaluation Loop: Post-execution review that updates markdown rules rather than harness code.
By keeping the runtime tiny, you can update business logic instantly by editing text files rather than refactoring orchestration code.
Rebuilding 20 Engineering Years in Three Weeks
The leverage of this architectural inversion is massive. In a benchmark demonstration, Garry Tan rebuilt an entire software platform that originally required 2 years and 10 engineers in just 3 weeks by utilizing a thin-harness setup where skills execute heavy tasks (Source: YC / Garry Tan). Furthermore, benchmark testing shows that orchestration design directly dictates agent reasoning quality. By optimizing the harness structure alone, LangChain DeepAgent climbed from outside the top 30 to the top 5 on TerminalBench 2.0 (Source: TerminalBench 2.0 / LangChain DeepAgent). A streamlined harness eliminates context pollution, allowing the model to focus its reasoning budget entirely on the task at hand.
The Feedback Loop That Cuts Failure by 66%
The greatest advantage of fat skills is continuous, non-code iteration. During YC Startup School in June/July 2026, a single matching skill processed over 6,000 founders (Source: YC Startup School / Garry Tan). Instead of refactoring orchestration code to fix edge cases, engineers ran a post-event improvement loop strictly updating the matching skill's markdown guidelines. In the subsequent event, founder matching resulted in 'OK' ratings dropping from 12% to 4%—a 66% reduction in mediocre outcomes without modifying the core software. Similarly, collaborative thin-harness designs improved Pass@1 accuracy by 5% on HumanEval over complex monolithic setups (Source: HumanEval / Garry Tan).
Engineering for the Age of Fluid Intelligence
Building AI systems on massive, opinionated frameworks is building on shifting sand. Models get smarter every quarter; hardcoded orchestration logic becomes technical debt the moment a new foundation model drops. By reducing your harness to a minimal 200-line runner and investing your time into modular, readable, fat skill files, you build an asset that appreciates rather than depreciates. You stop maintaining fragile glue code and start curating an organizational knowledge base that machines can instantly execute. The future belongs to those who keep their software thin and their operational judgment deep.
Sources: YC Startup School / Garry Tan (June/July 2026) | GStack / startup rebuild demo (YC / Garry Tan) | TerminalBench 2.0 / LangChain DeepAgent | Playwright CLI vs Chrome MCP explainer (Garry Tan) | HumanEval Benchmark analysis
No comments:
Post a Comment