From Vibe Coding to Reconciliation

A twelve-part series. It walks from a vanilla coding-agent workflow — prompting by feel — up the same ladder we climbed: persistent context, knowledge tiers, real-world verification, structural understanding, reusable skills, a written plan, an honest definition of done, and safe parallelism — to a reconciliation workflow. Each post is independently useful, and each ends on the limitation that motivates the next.

Parts marked coming are still being written; published parts link through to the post.

See the loop, the ladder, and the contrast

Diagram of the kazi reconcile loop: observe, diff, dispatch, re-observe, decide — repeating while predicates still fail, and exiting only on converged, stuck, or over budget. — The loop the whole series climbs toward: declare the goal as predicates, drive an agent, check against reality, repeat.

Diagram of the twelve-rung ladder from vibe coding at the bottom to a reconciliation workflow at the top; each rung is independently useful and you can start at any rung. — The rungs, bottom to top. Each post is one rung; you can start wherever you are today.

Before-and-after diagram contrasting working without kazi (trusting the agent's word, parallel agents colliding, green-on-a-laptop, stopping when it feels finished) against with kazi (every predicate verified with evidence, leased blast radius, a live deployed probe, and stopping only on converged, stuck, or over budget). — The without/with contrast the series argues for, rung by rung.

The ceiling of “looks good to me”published
Where prompting-by-feel quietly breaks: the agent decides it is finished, and there is no objective gate. The bottleneck is not the model — it is the missing gate and the missing structure.
Teach your agent to rememberpublished
Persistent context — a project memory file, conventions, checkpoints — so the agent stops re-learning your repo every session.
Decisions need a home: knowledge tiers (and keeping them honest)published
Give architecture, decisions, operations, and invariants distinct homes — then the hygiene that stops them rotting: linting for contradictions, trimming stale work, fixing tier drift.
Give your agent eyes (all the way to prod)published
Real-world verification: drive a browser, screenshot, exploratory-test — so “green locally” becomes “exercised live” — and carry it through to production and a stuck-deploy triage.
Stop re-reading the whole repo (and refactor without fear)published
Structural understanding and context economy: a code graph for callers and blast radius, compressing what you feed the agent, and reshaping code safely with ordered, build-green changes.
From prompts to skillspublished
Codify the good prompt you keep retyping into a reusable skill — the compounding move from one-off cleverness to a repeatable workflow.
Plan the work, then work the planpublished
Intent as an artifact: a checkable plan, tasks linked to outcomes, declared dependencies — instead of an oral to-do list.
A definition of “done” that can’t liepublished
The credibility centerpiece: tests, coverage, wiring, live probes — plus an adversary trying to break it — and why “the agent said done” is the wrong gate.
One developer, many agents (and how to recover)published
Parallelism without collisions: pools, claims, worktrees; coordinate on resources, not identities. Plus the resilience discipline — preflight before fan-out, resume a halted run.
The pattern underneath: reconciliationpublished
The conceptual turn: every rung above is the same loop — declare desired state, drive an agent, check against reality, repeat. The CI / Kubernetes analogy; truth in the controller.
Meet kazi: “done,” provenpublished
The product as the packaging of the preceding rungs into a controller: declare a goal as predicates, the agent drives kazi, it converges or stops honestly (stuck / over_budget).
Your on-ramppublished
Recap the ladder — you can start at any rung — wire kazi into Claude Code, harden your harness first, an honest “where it is going,” and a respectful call to try it.