/method
// method for reliable AI-assisted delivery
// orientation
// the entry
How I enter depends on how well I understand the problem. The phases are the same either way. What changes is how much steering it needs before it can safely enter the loop.
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.
// the methodology
Three moves: discovery, crank, validation. /rpi runs them as six phases: full auto or hand-driven.
Every phase writes to a persistent directory. Knowledge accumulates across sessions. Validation gates auto-retry on failure.
// the execution
/crank turns a plan into parallel waves of workers while keeping scope, dependencies, and proof visible.
THE 40% RULE — Keep context under 40% utilization. Past that, in my runs, the model starts dropping instructions. Beads issues preserve state when you need to start fresh.
// the flywheel
Each session writes back what it learned, so the next one starts from it. Learnings persist in git instead of vanishing with the context window.
THE INSIGHT — It's not agent orchestration, it's context orchestration. Recency-weighted: recent learnings weigh higher, stale knowledge is evicted.
// the tracking
Three systems work together: beads for issues, .agents/ for knowledge, 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: a panel, not a single reviewer.
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 closed, learnings stored, all in git. The next session inherits the gain instead of re-earning it.
// 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.
// the toolkit
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.
// the bigger picture
This is the discipline that makes AI dependable for engineers, and it's 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.