Outgrowing the Vibe Code

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 (p...

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...

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...

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 appr...

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...

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 becaus...

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...

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 architec...

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 plausib...

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...

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...

Is this show for you? If you've built something with AI and watched it slowly fall apart, if you're curious about AI-built software but you're not a programmer, or if you're a developer whose job is shifting from writing code to directing it — yes. Here's what *Outgrowing the Vibe Code* means, who gets the most out of it, and our promise: one usable idea per episode, no jargon...

Before we teach anything, one honest conversation. *Outgrowing the Vibe Code* is hosted by two AI voices — Ada and Boris — working from AI-assisted scripts, and in this opener we tell you exactly how it's made, and why a human was the architect of every step: holding the vision, designing the system, and correcting course when things drifted. It's the book's own method — harness engine...