The kazi blog
Hands-on writing about driving coding agents to an objective definition of done. The flagship series, From Vibe Coding to Reconciliation, walks the same ladder we climbed — from prompting by feel to a reconciliation workflow.
- From Vibe Coding to Reconciliation · Part 1
The ceiling of "looks good to me"
Where prompting-by-feel quietly breaks: your coding agent decides it is finished, you skim the diff, it looks good, and days later it is subtly wrong. The bottleneck is not the model — it is the missing objective gate and the missing durable structure. This is the first rung of the ladder out.
- From Vibe Coding to Reconciliation · Part 2
Teach your agent to remember
Your coding agent starts every session as a stranger to your repo — re-guessing your conventions, re-proposing the thing you already rejected. The fix is not a smarter model; it is a place where context persists across sessions. This is the second rung: give your agent a memory it reads before it touches a line of code.
- From Vibe Coding to Reconciliation · Part 3
Decisions need a home: knowledge tiers (and keeping them honest)
The single memory file works right up until it becomes a 400-line wall where settled decisions get relitigated and hard-won lessons get re-derived. The fix is to give different kinds of knowledge different homes — and a small habit to keep them from rotting. This is the third rung: structure your project's memory, then keep it honest.
- From Vibe Coding to Reconciliation · Part 4
Give your agent eyes (all the way to prod)
Green tests and a clean diff prove the code compiles, not that it works. The next rung is verification that reaches reality: drive a real browser, exercise the change live, and carry it all the way through a release pipeline to a running production — so 'done' means 'I watched it work where users will,' not 'the agent said so.'
- From Vibe Coding to Reconciliation · Part 5
Stop re-reading the whole repo (and refactor without fear)
Every session, the agent re-reads big swaths of your code just to orient itself — paying for all that context and still missing the one caller three files over. The next rung is structural understanding: a map of who calls what, so you feed the agent a sharp slice instead of the whole repo, and reshape code in an ordered sequence that keeps the build green at every step. With an honest note on when a map earns its keep and when grep is just fine.
- From Vibe Coding to Reconciliation · Part 6
From prompts to skills
You wrote a great prompt once — the careful instruction that made the agent do the thing right — and now you retype it every week, slightly differently, getting slightly different results. The next rung is codifying that prompt into a skill: a named, reusable procedure you invoke in one line instead of re-explaining from scratch. The compounding move from one-off cleverness to a workflow, with a concrete before and after you can copy today.
- From Vibe Coding to Reconciliation · Part 7
Plan the work, then work the plan
Your intent for the week lives in your head and a scatter of chat messages: a mental to-do list you re-derive every morning, with no shape you and the agent can both see. The next rung is making that intent an artifact — a plain checkable plan, each task tied to the outcome it enables and the tasks it depends on. Not a Gantt chart, just a Markdown file you and the agent work from and tick off together, so the work has edges instead of a vibe.
- From Vibe Coding to Reconciliation · Part 8
A definition of "done" that can't lie
Your agent says "done — tests pass, everything works," and most of the time it is telling the truth as it understands it. That is the problem. A self-report is an opinion, and an opinion can only ever come back green. The next rung is giving "done" a definition that has the authority to come back red: tests it did not grade itself on, a wiring check, a live probe against reality, and an adversary actively trying to break it. Truth about whether the work is finished has to live somewhere the agent cannot simply assert it into being.
- From Vibe Coding to Reconciliation · Part 9
One developer, many agents (and how to recover)
One agent at a time leaves your backlog crawling, so eventually you run two or three at once — and discover that giving each its own task is not enough to keep them out of each other's way. Two agents can hold completely different tasks and still edit the same files, because a task says who owns the work, not who is allowed to touch the code. The rung up is coordinating on resources (the files a change touches) instead of identities, plus the small discipline that makes parallel runs survivable: a preflight check before you fan out, and a way to resume a halted run without redoing the work that already finished.
- From Vibe Coding to Reconciliation · Part 10
The pattern underneath: reconciliation
Nine rungs in, the techniques start to rhyme. Memory, eyes, a written plan, an objective "done," parallel agents that recover — each one turned out to be the same small loop wearing a different hat: declare the state you want, drive an agent toward it, check the result against reality, and go around again until it holds or you stop honestly. This post names that loop. It is a borrowed idea — the control loop behind CI and behind Kubernetes — pointed at coding goals, and its one rule is that the truth about "done" lives in the controller, never in the thing being driven.
- From Vibe Coding to Reconciliation · Part 11
Meet kazi: "done," proven
Ten rungs of this series assembled a control loop out of commodity parts: a memory file, eyes on prod, a written plan, an objective "done," parallel agents that recover. The last post named the loop and then admitted the obvious gap — I was still running it by hand, lap after lap. This post introduces the tool that packages those rungs into an actual controller. You declare a goal as machine-checkable predicates, your agent drives kazi, and it converges or it stops honestly: stuck, or over budget. No new magic — just the loop you already built, with a home that is not your attention. Strictly what it does today.
- From Vibe Coding to Reconciliation · Part 12
Your on-ramp
Twelve posts ago this series started where almost everyone starts: prompting a coding agent by feel and trusting it when it said "done." Each rung after that was one more piece of structure we reached for when that trust broke — memory, eyes on prod, a written plan, an objective gate, parallel agents that recover — and the last two posts named the loop underneath all of them and handed it to a controller. This final post is the on-ramp: a recap of the whole ladder so you can start at whatever rung you are actually on, an honest pass on hardening your harness before you let an agent run unsupervised, the copy-paste wiring to drive kazi from your coding agent, where the project is genuinely going next, and a respectful invitation to try it on something real.