The Vibe Father
Playbook
Most people don't pair with an AI. They dictate to it. They type a request, look away, and come back hoping the code is done — treating the agent like a vending machine and themselves like a customer. It works for trivial tasks and falls apart on anything real, because the moment the problem gets interesting, dictation has no mechanism for the back-and-forth that solves hard problems. Real pair programming is a conversation between two people looking at the same code, and you can have exactly that with an agent — if you change how you work. This is the mindset shift and the habits that come with it.
The shift: from dictation to pairing
Dictation is one-way. You issue an instruction, the agent produces output, you accept or reject the whole thing. Pairing is a loop. You think out loud, the agent responds, you steer, it adjusts, and the solution emerges from the exchange. The difference isn't the tool — it's whether you stay in the conversation or check out and wait for the answer.
The tell that you've slipped into dictation: you're surprised by what comes back. In real pairing you're never surprised, because you've been watching and steering the whole way. If the agent's output regularly astonishes you — good or bad — you've been dictating, not pairing.
Habit 1: Think out loud
The single biggest upgrade is to narrate your reasoning, not just your requests. Instead of "add caching to this endpoint," say: "This endpoint is slow because it hits the database on every request, and the data only changes hourly, so I'm thinking we cache it — but I'm worried about stale reads after an update. How would you handle invalidation?"
The second version gives the agent your constraints, your worry, and your reasoning — so it can pair with your actual intent instead of guessing at it. You'll find the agent catches things you missed, precisely because you told it what you were thinking. Thinking out loud isn't a courtesy to the model; it's how you get a collaborator instead of an order-taker. More on shaping intent well is in prompt engineering for coding agents.
Habit 2: Keep the driver's seat
In human pairing there's a driver, who types, and a navigator, who thinks ahead. With an agent it's tempting to hand over both roles and become a spectator. Don't. You stay the navigator — always. You decide the direction, the architecture, the tradeoffs. The agent drives the keys, but you own where the car goes.
Concretely, that means you make the decisions that are expensive to reverse — the data model, the module boundaries, the dependencies — and the agent makes the decisions that are cheap to change, the implementation details inside those boundaries. When the agent proposes an architectural choice, you evaluate it; you don't rubber-stamp it. The moment you're accepting decisions you don't understand, you've given up the navigator seat, and a navigator-less pair drifts.
Habit 3: Review as you go, not at the end
The dictation trap's worst symptom is the giant unreviewed diff — you let the agent run for twenty minutes and now there are forty changed files and you review none of them because it's too much. Pairing reviews continuously. You read each meaningful change as it happens, while the context is fresh and the change is small enough to actually understand.
- Prefer small, reviewable steps over big autonomous runs when the work is unfamiliar or important.
- Read each diff as it lands. If you don't understand it, ask — "why did you do it this way?" — before moving on.
- Catch drift early. A small wrong turn caught at change three is a two-minute fix; caught at change thirty it's an afternoon.
Reviewing as you go is slower per step and dramatically faster overall, because you never accumulate a pile of code you don't understand and can't debug. Our fuller review process is in context engineering for coding agents.
Habit 4: Hand off cleanly
Sometimes you step away and let the agent run autonomously — that's fine and often right. But a handoff is a real thing with real hygiene, not just walking off. Before you hand off, do two things. First, checkpoint: commit the current known-good state so a bad autonomous run is a thirty-second reset, not an afternoon of untangling. Second, hand off with a crisp brief — the specific task, the success criteria, and the boundaries ("don't touch the auth module"). A vague handoff to an autonomous agent is how you return to a mess. A precise one is how you return to progress.
git add -A && git commit -m "checkpoint: before autonomous test-writing run"The handoff also runs the other way. When the agent hands work back to you — "I've implemented it but I'm unsure about the edge case where the user has no email" — that's a good handoff, and you should reward it by engaging, not just approving. An agent that flags its own uncertainty is pairing well; meet it there.
Habit 5: Know when to grab the keyboard
The best pair programmers know when to stop talking and just type. Same with agents. There are moments when driving it yourself is faster than steering it, and recognizing them is a skill:
- When the agent is circling. Two or three failed attempts at the same thing means it's stuck in a groove. Grab the keyboard, make the change yourself, and hand it back. Don't grind a fourth attempt.
- When you know exactly what you want. If the change is three lines and you can see them, typing them is faster than describing them. Reserve the agent for where its leverage is real.
- When the stakes are high and the change is small. A one-line fix to a payments path is faster to write and verify yourself than to specify, review, and trust.
- When you're learning the codebase. Sometimes typing it yourself is how you build the mental model you need to steer well later. Don't outsource the understanding you'll need.
The whole mindset, in one line
You are the senior engineer in the pair, and the agent is a fast, tireless, occasionally overconfident junior who never gets bored. Your job isn't to type less — it's to think out loud, keep the wheel, review continuously, hand off cleanly, and grab the keyboard when that's the faster move. Do that and the agent stops being a vending machine and starts being a genuine collaborator that makes you faster without making you dumber. The tools you use — a single terminal, or something like The Vibe Father running a whole team with checkpoints baked in — matter far less than whether you're pairing or dictating. Pair, and everything downstream gets better.
