/method
// method for reliable AI-assisted delivery
You can read the principles at /about, see the artifacts at /proof, and then end up here: the operating loop that makes the work reviewable, testable, and safe to ship. The named pieces below — /rpi, /crank, beads, ao — are just the tools that run it. The idea underneath is plain: DevOps and SRE discipline, applied to AI work.
How I enter depends on how well I understand the problem. This is what vibe coding looks like when the goal is reliability, not vibes.
Full auto. Six phases, zero prompts. The lifecycle carries its own validation.
Run discovery, then review the plan and pre-mortem before any code. Steer the slices before cranking.
Don't even know the shape yet. Brainstorm first, then run discovery once the direction is clear.
Same phases either way. The difference is how much steering the problem needs before it can safely enter the delivery loop.
// the methodology
Three moves: discovery, crank, validation. Full auto or hand-driven. Council-first, a panel of judges signs off before and after code. Same discipline either way: make the work inspectable before it ships.
// /rpi runs three moves — discovery (research + plan + pre-mortem), crank, validation (vibe) — expanded into six phases:
Every phase writes to a persistent directory. Knowledge accumulates across sessions. Validation gates auto-retry on failure. The point is not autonomy for its own sake; it is a delivery system with memory.
// the execution
/crank turns a plan into parallel waves of workers while keeping scope, dependencies, and proof visible.
Takes an epic ID. Spawns workers for each wave. Coordinates dependencies automatically.
The 40% rule: Keep context under 40% utilization. Above 60%, Claude starts forgetting instructions. Beads issues preserve state when you need to start fresh.More on this →
// the flywheel
Every session makes the next one safer. Learnings compound into durable context instead of disappearing with the context window.
Recent learnings are weighted higher; stale knowledge is evicted. Each session starts with curated knowledge from the ones before it, not because the model improved, but because the compiled context did.
The insight: It's not agent orchestration, it's context orchestration. Loading the right knowledge at the right time is the whole game.
// the tracking
Three systems work together: beads for issues, .agents/ for knowledge, and ao for the flywheel. The stack makes context survive execution.
Git-backed issue tracking. Survives sessions, crashes, and context resets.
Persistent memory. Research, plans, learnings, patterns, all in git.
Go CLI, ~70 commands for knowledge compounding. The memory half of AgentOps.
// the validation
Multi-model councils validate before and after implementation. Not one reviewer, a panel.
4 judges review the plan before any code is written. Missing requirements, feasibility, scope, spec completeness. FAIL → re-plan automatically.
6 judges review the code after implementation. Quality, security, architecture, complexity, UX. FAIL → re-crank automatically.
The ratchet:Progress is locked permanently. Code is merged. Issues are closed. Learnings are stored. You can't un-ratchet, just like you can't un-deploy a running service.
// the replays
Real commits from this repository showing the method in action.
7fd5e98May 2026Add the /training page (coding-agent training lane) (#37)
Scoped a new lane, planned the page, shipped it behind review. Plan → implement → land.
1069b51May 2026Feature the ADHD essay, lived opening, voice-pass /training (#38)
The validation gate in practice: a voice-pass on the copy before it shipped, not after.
f2b3008May 2026Act on mixed-vendor post-mortem findings (#39)
A post-mortem across the site became a punch-list, then concrete fixes. The learning ratchets forward.
Fast AI work becomes reliable when the loop has memory, validation, and receipts.
// the toolkit
AgentOps is the coding-agent plugin behind this method, works with Claude, GPT, and other models, and runs the workflow as portable skills.
AgentOps
Coding-agent plugin for any model. Go CLI + skills + marketplace kits.
This website, the CLI, the skills, the marketplace kits, all built with the same workflow they document. The repo is the proof. Every commit, session, and learning extraction happened through this loop.
This is the discipline that makes AI dependable for engineers — and what I teach teams at /training. I'm now translating it for people who aren't, /ai-partner brings the same context, boundaries, and safety to everyone, in plain language.