Outgrowing the Vibe Code

Your agent starts out able to read files, run shell commands, and search — tools are how it reaches past that baseline to touch the outside world. Ada and Boris explain what a tool actually is, then unpack MCP, the Model Context Protocol: the open standard — think "USB for AI agents" — that lets one agent plug into any external system instead of everyone hand-wiring bespoke integrations, whether over local stdio o...

Knowing what belongs in an AGENTS.md and actually writing a good one are two different skills. Ada and Boris cover the four cardinal rules: keep it under sixty lines (research out of ETH Zurich found that agent-generated instruction files actually degraded performance by over twenty percent), be concrete instead of abstract, make it iterative, and don't duplicate what a linter already enforces. They walk through progressive disclos...

Every major coding agent automatically reads one file before it looks at a single line of your code — Claude Code reads CLAUDE.md, Codex reads AGENTS.md, Cursor reads .cursorrules. It's the one piece of context you're guaranteed the agent has every session, which means every line in it competes for space the agent needs to read your actual code. Ada and Boris break down the six things that actually belong in that file: build ...

Writing your architecture rules down isn't enough — under pressure, an agent will quietly skip them, the same way a painter drifts past their own tape line. Ada and Boris walk through the three levels of enforcement that actually hold: documentation the agent reads, a custom linter whose error messages double as fix-it instructions, and a CI/CD gate that guarantees nothing broken ever reaches main. They unpack the single mach...

An agent has no institutional memory — every session it re-infers your codebase's structure from whatever code is in context. That means the erosion that takes a human team a year can happen in a single day. But constraints don't slow agents down; they make them faster. Ada and Boris walk through the foundational design pattern that turns this dynamic in your favor: layered architecture (presentation, application, domain, inf...

Becoming a harness engineer doesn't mean starting over — it means your skills get re-weighted. Ada and Boris break down what stays critical (code comprehension, architecture, debugging, domain knowledge), what becomes newly critical (specification writing, constraint design, feedback-loop design, triage at scale), and what matters less than it used to (typing speed, memorizing syntax, writing boilerplate). Then come the four ...

The first three chapters made the case — the bottleneck isn't the model, it's the harness. Now the question is: what does building that harness actually look like on a real day? Ada and Boris walk through the full shape of harness engineering work: two complementary halves (environment building and work management) that run simultaneously, and the central reflex that defines the job — when something breaks, don't fix th...

Here's the counterintuitive truth: giving an AI agent fewer choices makes it perform better. Vercel ran the experiment — 15 tools, 80% accuracy; 2 tools, 100% accuracy. Ada and Boris dig into why: every decision an agent makes costs tokens, and when the harness narrows the decision space, the agent spends its reasoning on the actual problem instead of navigating the meta-problem of how to approach it. The episode covers what ...

The model is brilliant — but it starts every session from a blank slate, can't enforce its own boundaries, can't grade its own work, and doesn't know what it shouldn't touch. Ada and Boris name the six things an agent structurally can't provide for itself — persistent memory, architectural constraints, verification mechanisms, tool access, curated context, and governance — and show exactly what the harness has...

Every time the agent does something dumb, there's a comforting little prayer: the next model will fix it. Ada and Boris open Chapter 3 by showing why that's backwards — AI coding has compressed three eras into three years (prompt engineering, then context engineering, then harness engineering), and a frontier model that scores 90%+ in a clean test still falls apart on real work. Not because it can't reason, but because it's a...

Your agent says "done" with total confidence — but can you trust it? Ada and Boris close out the failure-modes chapter with the two trust failures: the fixation loop, where the agent fixes one thing and breaks another round after round because nothing checks the whole picture, and confidence without verification, where every answer arrives equally certain even when the agent is flat-out wrong (and will happily agree with you ...

Your agent's code can look perfect and still rot from the inside. Ada and Boris walk through the three ways it happens: the copy-paste explosion — the agent reinventing the same little utility instead of reusing yours, at roughly eight times the duplication rate of human-written code; phantom completions — features it cheerfully calls "done" that were never actually run; and architecture erosion — a clean, layered...

Your coding agent keeps making confident mistakes — calling a function with the wrong arguments, drifting away from your naming conventions file by file, and starting every session like it's never met your project. In this episode, Ada and Boris trace all three back to a single root cause: the agent can't remember. They unpack context overflow (the agent filling a partial view with plausible-but-wrong guesses), convention dri...

Last episode named the wall — this time, why your instincts for getting past it all fail. Ada and Boris dig into why longer prompts, fresh sessions, and micromanaging the AI don't work: each one treats a structural problem like a communication problem. The real story is that the agent isn't broken — it's a stateless predictor missing the infrastructure *around* it (memory, verification, architecture), and output quality...

You build an app with AI over a weekend and it feels like magic — then three weeks later it's fighting you at midnight. That's *the wall*, and almost everyone hits it. In our first full episode, Ada and Boris break down why AI-built projects feel so good at first, the four ways they start to crack as they grow — repetition, contradiction, phantom completion, and cascade failure — and the unsettling "perception gap...