Outgrowing the Vibe Code

You started by tossing prompts at an AI and hoping the app held together. It worked... until it didn't. Outgrowing the Vibe Code is the show about what comes next.Each episode, two builders dig into the messy, fascinating journey from haphazard "vibe coding" to real, enterprise-grade systems that write code for you. We get hands-on with the stuff that makes it work — harnesses, spec-driven development (SDD), and agent loops — without the jargon or the hype.Whether you're still winging it or wiring up your first self-writing pipeline, pull up a chair. It's fun, it's casual, and it's the con

31 episodes

10d ago latest

3x a week cadence

English language

▶ Play latestRSS feed Website Technology

https://otvc-podcast.judgementoverai.com/feed.xml

Episodes 34

Tools and MCP — What Your Agent Can Reach
1mo ago · 11:05
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 or remote HTTP, and exposing tools, resources, and prompts. The catch: every tool's description is loaded into the context window before you type a word, so five perfectly useful tools
Writing One That Actually Works
1mo ago · 10:19
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 disclosure — giving the agent the essentials up front and pointing to deeper docs only when needed — plus what never belongs (decision history, aspirational goals, personal
What Goes In Your AGENTS.md
1mo ago · 10:18
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 and test commands (the highest-impact section, because it lets the agent verify its own work instead of guessing), project structure as a mental model rather than a file l
Make Constraints Mechanical, Not Aspirational
1mo ago · 10:35
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 machine-readable architecture file all three levels read from — including the banned-patterns section that catches behavioral violations layer rules alone can't — then walk a
Architecture as the Agent's Guardrail
1mo ago · 11:56
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, infrastructure), where dependencies flow downward only and the domain layer depends on nothing, giving the agent a deterministic answer to "where does this code go?" They cov
The New Skills and Mindset Shifts
1mo ago · 11:06
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 mindset shifts the job actually demands: from "how do I build this" to "how do I describe this so it gets built correctly"; from "fix the bug" to "fix the system that allo
A Day in the Life of a Harness Engineer
1mo ago · 11:27
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 the code, ask what structural change would prevent the whole class of problem. The episode walks a concrete day: morning PR review where one bad PR becomes two permanent linter ru
Why Constraints Make Agents Better
1mo ago · 11:29
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 this means practically — stop waiting for the next model, invest in the harness you have, and reframe every frustration as a harness problem — plus the "build for deletion
Six Things an Agent Can't Give Itself
2mo ago · 12:55
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 to supply in each case. The episode lands on the formula that holds the whole framework together: Agent = Model + Harness. If you're not the model, you're the harness — and that reframe
The Agent Isn't the Hard Part
2mo ago · 11:50
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 brilliant new hire dropped in with no onboarding, no tests, no guardrails. With three receipts — LangChain jumping 13.7 points by changing only the harness, Vercel going
When You Can't Trust "Done"
2mo ago · 11:21
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 to boot). Then they step back to the big payoff: all eight failures across the chapter are one root cause — the agent isn't broken, it's unsupported, like a brilliant new
When the Code Rots
2mo ago · 11:21
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 design quietly collapsing as the agent takes one shortcut after another. The through-line: every one is invisible at the level of a single change and only shows up when you step back
When the Agent Forgets
2mo ago · 12:41
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 drift (re-inferring your rules from whatever code is in front of it, until the inconsistency becomes the rule), and the blank-slate problem — a stateless tool that forgets ev
Why Trying Harder Fails and the Name for the Fix
2mo ago · 12:45
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 is set by the environment, not the model. That discipline has a name — harness engineering — and it's what the rest of the show is about. From Chapter 1 of *Harness Engineering
The Honeymoon and the Wall
2mo ago · 12:34
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" that hides the wall while you're standing right at it. From Chapter 1 of *Harness Engineering for Vibe Coders* by J.M. Crider — go deeper at hamiltonroadagility.com/vibe
Who This Is For
2mo ago · 3:05
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 left unexplained, all in under 15 minutes. Book: *Harness Engineering for Vibe Coders* by J.M. Crider — hamiltonroadagility.com/vibe
How This Show Is Made
2mo ago · 4:53
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 engineering — demonstrated on itself. Plus a quick look at the journey ahead. New here? Start with this. Book: *Harness Engineering for Vibe Coders* by J.M. Crider — hamiltonroadagility.com/vibe
Ch 7, Pt 2: Fewer Tools Win
1mo ago · 11:26
Chapters 00:00 — Intro 01:46 — Why Fewer Tools Win 04:22 — When a Tool Earns Its Place 06:02 — Descriptions Are Instructions 07:51 — Loading Tools On Demand 09:33 — Midroll Break 10:56 — Recap Music Music by The Everlove: "Goes Like This" Music by Cumbia Deli: "Cafecito por la Manana"
Ch 7, Pt 3: Tool Security
1mo ago · 9:54
Chapters 00:00 — Intro 01:40 — Security scales with power 03:10 — When a tool description attacks 04:58 — Least privilege 06:44 — Five ways to get it wrong 08:16 — Midroll Break 09:25 — Recap Music Music by The Everlove: "Goes Like This" Music by Cumbia Deli: "Cafecito por la Manana"
Ch 8, Pt 1: The Invisible Resource
1mo ago · 10:30
Chapters 00:00 — Intro 01:47 — The resource you can't see 03:13 — Bigger isn't better 05:10 — Where the tokens actually go 06:46 — Context rot 08:34 — Midroll Break 09:59 — Recap Music Music by The Everlove: "Goes Like This" Music by Cumbia Deli: "Cafecito por la Manana"
Ch 8, Pt 2: Five Strategies and the Context Budget
1mo ago · 12:12
Chapters 00:00 — Intro 01:58 — Start Fresh 04:06 — You Are the Curator 06:07 — Firewalls and Infinite Memory 08:22 — The Context Budget 10:14 — Midroll Break 11:39 — Recap Music Music by The Everlove: "Goes Like This" Music by Cumbia Deli: "Cafecito por la Manana"
Ch 8, Pt 3: Patterns and Mistakes
1mo ago · 10:58
Chapters 00:00 — Intro 01:41 — Read-grep-act 03:18 — Summarize and offload 05:07 — The fresh-session checkpoint 06:57 — Four common mistakes 09:04 — Midroll Break 10:24 — Recap Music Music by The Everlove: "Goes Like This" Music by Cumbia Deli: "Cafecito por la Manana"
Ch 9, Pt 1: Back-Pressure and the Verification Stack
26d ago · 10:14
Chapters 00:00 — Intro 01:52 — The confident junior developer 03:06 — What back-pressure actually is 04:48 — The verification stack 06:50 — Make it automatic 08:28 — Midroll Break 09:39 — Recap Music Music by The Everlove: "Goes Like This" Music by Cumbia Deli: "Cafecito por la Manana"
Ch 9, Pt 2: The Self-Correction Loop
25d ago · 10:21
Chapters 00:00 — Intro 01:51 — How the loop connects 03:31 — When the loop won't stop — the doom loop 05:05 — Show the failures, hide the wins 06:43 — Back-pressure when you have no tests 08:28 — Midroll Break 09:45 — Recap Music Music by The Everlove: "Goes Like This" Music by Cumbia Deli: "Cafecito por la Manana"
Ch 9, Pt 3: Structural Back-Pressure — Feature Lists and Hooks
24d ago · 10:24
Chapters 00:00 — Intro 01:41 — The feature list 03:20 — Hooks that check for you 05:01 — Four ways to break the loop 07:12 — Layers that overlap 08:29 — Midroll Break 09:52 — Recap Music Music by The Everlove: "Goes Like This" Music by Cumbia Deli: "Cafecito por la Manana"

Episodes

Reading the feed…

More Technology shows

Outgrowing the Vibe Code

Episodes 34

Tools and MCP — What Your Agent Can Reach

Writing One That Actually Works

What Goes In Your AGENTS.md

Make Constraints Mechanical, Not Aspirational

Architecture as the Agent's Guardrail

The New Skills and Mindset Shifts

A Day in the Life of a Harness Engineer

Why Constraints Make Agents Better

Six Things an Agent Can't Give Itself

The Agent Isn't the Hard Part

When You Can't Trust "Done"

When the Code Rots

When the Agent Forgets

Why Trying Harder Fails and the Name for the Fix

The Honeymoon and the Wall

Who This Is For

How This Show Is Made

Ch 7, Pt 2: Fewer Tools Win

Ch 7, Pt 3: Tool Security

Ch 8, Pt 1: The Invisible Resource

Ch 8, Pt 2: Five Strategies and the Context Budget

Ch 8, Pt 3: Patterns and Mistakes

Ch 9, Pt 1: Back-Pressure and the Verification Stack

Ch 9, Pt 2: The Self-Correction Loop

Ch 9, Pt 3: Structural Back-Pressure — Feature Lists and Hooks

Episodes

More Technology shows

AppleVis Podcast

Material

Área de Transferência

Super Feed

Don't Panic

HTML All The Things - Web Development, AI, and Developer Careers

Episodes 34

Tools and MCP — What Your Agent Can Reach

Writing One That Actually Works

What Goes In Your AGENTS.md

Make Constraints Mechanical, Not Aspirational

Architecture as the Agent's Guardrail

The New Skills and Mindset Shifts

A Day in the Life of a Harness Engineer

Why Constraints Make Agents Better

Six Things an Agent Can't Give Itself

The Agent Isn't the Hard Part

When You Can't Trust "Done"

When the Code Rots

When the Agent Forgets

Why Trying Harder Fails and the Name for the Fix

The Honeymoon and the Wall

Who This Is For

How This Show Is Made

Ch 7, Pt 2: Fewer Tools Win

Ch 7, Pt 3: Tool Security

Ch 8, Pt 1: The Invisible Resource

Ch 8, Pt 2: Five Strategies and the Context Budget

Ch 8, Pt 3: Patterns and Mistakes

Ch 9, Pt 1: Back-Pressure and the Verification Stack

Ch 9, Pt 2: The Self-Correction Loop

Ch 9, Pt 3: Structural Back-Pressure — Feature Lists and Hooks