The Vibe Father
Field notes
We have made every one of these mistakes, most of them more than once, and we have watched otherwise-excellent engineers make them the day they picked up an agent. The good news is that every one has a clean fix, and none of the fixes are exotic — they are just discipline. Here are the eleven that bite everyone, in roughly the order they'll bite you.
1. Trusting "tests pass"
The mistake: the agent says "all tests passing ✅" and you believe it. That emoji is a claim, not a build status, and models will occasionally report work they did not do.
The fix: verify externally. Run the real build and the real test suite yourself — or use a harness that runs them for you and refuses to go green on anything less than a genuine pass. Never let the thing that wrote the code be the only witness that the code works.
2. One giant prompt
The mistake: dumping the entire feature — schema, API, UI, tests, deployment — into a single wall-of-text prompt and hitting go. The agent does a mediocre job on all of it because it can't hold the whole thing coherently.
The fix: decompose. One clear task per prompt, each with a defined output. Small, bounded asks have dramatically higher first-attempt success rates than heroic ones. If you wouldn't hand it to a junior as a single ticket, don't hand it to an agent as a single prompt.
3. No checkpoints
The mistake: letting an agent make forty edits across the repo with no restore point. When run thirty-eight goes wrong, you're doing git archaeology to figure out which of the last two hours to keep.
The fix: checkpoint before anything risky, so "undo" is one click instead of a forensic investigation. We wrote up the mechanics in checkpoints and worktrees for AI coding. This single habit converts most agent disasters into shrugs.
4. Scope creep
The mistake: you ask for a bug fix and the agent "helpfully" refactors three unrelated modules, reformats a file, and renames a function you liked. Now your one-line fix is a 400-line diff nobody can review.
The fix: pin the scope in the prompt — "change only X, touch nothing else" — and reject diffs that wander. A reviewable change is a small, focused change. Breadth is where bugs hide.
5. Marrying one model
The mistake: welding your whole workflow to one lab's model because it was the best the month you started. Model supremacy churns roughly monthly now; the leader in July is mid-pack by fall.
The fix: stay model-agnostic so you can swap when the board changes — and it changes constantly, as our live benchmarks keep proving. Pick tools that let models compete inside them rather than tools that lock you to one.
6. Skipping the repro in debugging
The mistake: you describe a bug in prose and ask the agent to fix it. It fixes a bug — maybe not yours — and you can't tell, because there was never a failing case to go green.
The fix: reproduce first. A failing test or a minimal repro turns debugging from vibes into a closed loop: red, then green, then verified. Our full loop is in the AI debugging workflow. No repro, no fix — just a guess wearing a fix's clothes.
7. Dumping the whole repo as context
The mistake: pasting the entire codebase in "so it has everything." This drowns the signal, blows your token bill, and often makes output worse because the model can't find the five files that matter.
The fix: give it the right context, not all the context. The relevant files, the interface it's touching, the one example to follow. Curated context beats exhaustive context every single time.
8. Letting an agent grade its own homework
The mistake: the same agent that wrote the code also reviews it and declares it good. It is structurally blind to its own assumptions, so it approves its own bugs with total confidence.
The fix: separate the reviewer — ideally a different model from a different lab, which won't share the same blind spots. A builder and an independent reviewer catch things a soloist never will.
9. No spec
The mistake: "build me a dashboard." The agent builds a dashboard — confidently, quickly, wrong. Every unstated assumption becomes a decision it makes for you, badly.
The fix: write the spec first. What it does, what it doesn't, the inputs, the edge cases, the definition of done. Ten minutes of spec saves an hour of "no, not like that." In 2026, your prose is the source code; write it like it matters.
10. Deploying at midnight
The mistake: the agent finishes at 11:58pm, everything's green, you ship to production and go to bed. At 12:20am it's on fire and you're the only one awake to notice — which you aren't, because you're asleep.
The fix: ship when you can watch. Agent-built changes still need a human near the deploy for the first few minutes. "It works on my machine at midnight" is where outages are born. This is a human-in-the-loop discipline, not a tooling one.
11. Ignoring security
The mistake: shipping agent output without a security pass. Agents happily produce hardcoded secrets, missing auth checks, injectable queries, and permissive CORS, because they optimize for "works," not "safe."
The fix: make security a required review gate, not an afterthought. Scan for secrets, check authz on every new endpoint, and treat all agent-generated input handling as guilty until proven safe. Our checklist is in the AI coding agent security guide. Fast and insecure is just slow with extra steps.
| Mistake | One-line fix |
|---|---|
| Trusting "tests pass" | Verify externally |
| One giant prompt | One task per prompt |
| No checkpoints | Restore point before risk |
| Scope creep | Pin scope, reject wandering diffs |
| Marrying one model | Stay swappable |
| No repro when debugging | Failing case first |
| Whole repo as context | The right five files |
| Self-graded homework | Independent reviewer |
| No spec | Write intent before code |
| Midnight deploy | Ship when you can watch |
| Ignoring security | Security is a gate |
If you recognized your own week in that list, welcome — so did we. The pattern underneath almost all of them is the same: agents are astonishingly capable and completely unaccountable, so the discipline that used to be optional is now the whole game. Get these eleven into muscle memory and the difference in output quality isn't subtle — it's the difference between shipping and untangling.
