This repo is a Claude Code plugin marketplace. It hosts the slice-development workflow as an
installable plugin (dev), and it is the workshop where that workflow is measured and improved.
The workflow used to be a template you copied into each project and filled in. It is now a plugin
you install once into ~/.claude; each project describes itself through its
.kubecoder/project.yaml manifest (read by kc) and an .aiworkflowrc at its root. This version
targets the KubeCoder environment — it is kc-native and expects kc on PATH (always true inside
a KubeCoder pod).
The slice pipeline: /dev:triage → /dev:plan-slice → /dev:run-slice.
- Triage is the operator's own chat skill. It files a batch of cards and findings as slices, the questions first and the slices as their consequence.
- Planning and the run are stages. Pilot, the project manager, runs each as a work item. The
skill puts every ask it has into a document Pilot shows the operator, ends its turn, and
carries the answers out when Pilot writes them back
(
pilot.md). The close-out is the run's continuation, not a step of its own. Without Pilot, the skill prints each document's path and the operator answers in the file. - Beside them,
/dev:onboardbrings a repo onto the pipeline,/dev:inboxsorts every project's tracker inbox with the operator ahead of triage, and/dev:arch-designwrites a design with its options. - Two skills are no workflow.
/dev:document-formatis the format of a document Pilot reads, and/dev:writingis how everything the operator reads is written.
plan-slice has the plan-preparer ground the slice and put its requirements asks, then
drives a plan-writer/plan-reviewer round (plan_loop.py) to a reviewed phase queue;
run-slice launches a kc-native run loop (run_loop.py) that takes each phase through a bounded
loop — fetch → branch → code-writer → test gate + test-fixer → consult-funded review rounds
against a rising bar → ff-merge → ✅ DONE — then closes the slice out with a loop-tail gate
sweep, a completion consult, a test phase and a doc phase, spawning every agent as a headless
kc session. Both loops run inside the stage's turn and stop at a question with a document for
the stage to register. The gate is kc project test and lint, run by the loop itself: detecting
green needs no model, only fixing red does. Files are durable; sessions are ephemeral; scripts drive, agents
judge.
The plan is the queue. One plan.md per slice holds phases as ### P<id> — <title> headings,
each opening with a Target: line naming a kc project list component or a sibling repo. Document
order is authoritative; only the driver stamps a phase done. Every agent in the loop may edit the
plan — appending a phase is how work grows, bounded by a generation bar (work the plan owes
first, blocking work only after, then the operator). Everything out of the loops' scope goes in
one close-out report per slice
(close-out.json, rendered at the run's end as close-out.md, the document Pilot reads, and
close-out-record.md; created at planning, written by every agent as it goes): nothing from a
run is carded per finding. The author of an entry labels what it is, a table in the tool routes
it, the operator answers what comes to them in Pilot and the run's continuation carries the
answers out.
plugins/dev/— the plugin: 8 skills, 11 agents, the tools (run_loop.py,plan_loop.py,asks.py,close_out.py,checks.py,github_target.py,close_slice.py,slice_cards.py,slice_cost.py,turn_profile.py,preflight.py,project_config.py,redact_secrets.py,spec_check.py,long_run.py,allocate-next-slice.sh, with their suites), and the contract docs (pilot.md/run-loop.md/runner-state.md/plan-loop.md/plan-template.md/agent-dispatch.md/close-out.md/close-out-template.md, plusproject-contract.md,preflight.md,spec-tree.md)..claude-plugin/marketplace.json— makes this repo installable.
kc project test and kc project lint gate the plugin from this repo — the suites are the reason
the workflow is safe to change here.
/plugin marketplace add <this repo> # e.g. /plugin marketplace add /work/AIWorkflow
/plugin install dev@aiworkflow
Then make a repo adoptable — author a .kubecoder/project.yaml and an .aiworkflowrc (where the
spec repo, the procedure docs and the optional phases live). Preflight enforces the whole
contract and tells a new repo exactly what is missing. See docs/ADOPTING.md.
plugins/dev/tools/slice_cost.py— what a slice cost, priced from the run's ownstate.json/plan_state.jsonrecords and the transcripts they name, and — throughturn_profile.py, which replays each transcript turn by turn — what its turns did, per role. Both ship with the plugin rather than living here, because they read a state format the plugin owns and every run writes its own numbers.workflow-improvements/— the R&D / evidence trail behind the workflow's design: the July 2026 cost investigation and the plan it produced, frozen as written. It describes the task runner that preceded the plugin, not the loops that run today; the story since isdocs/rationale/history.md.archive/quality/— the retired quality capability (quality-improver,quality-issue-finder,refactor-audit) and thecode_healthgrader, one folder per source project because the copies drifted apart. Parked while the tool is rebuilt;/dev:onboardsweeps each project's copies in here. Seearchive/quality/README.md.
docs/ADOPTING.md— install the plugin and make a repo adoptable (manifest +CLAUDE.mdentries), with a worked example.docs/AUTHORING.md— the durable rules for writing/maintaining agents, skills, and docs so they stay lean and drift-free.docs/rationale/— the explanation layer: why the pipeline is shaped the way it is, with the incidents and numbers behind each rule — the flow in one read, the design principles, the history and reversals, the imp 5831 rovement catalogue, how runs are measured, how the research literature was used, the close-out report's case, and how planning came to its documents.plugins/dev/docs/— the plugin's own contract:pilot.md(a stage as a Pilot work item: the turns, the brief, the documents, the continuation),run-loop.md(the phase queue and the consult/test/doc ladder) withrunner-state.md,plan-loop.md,plan-template.md,agent-dispatch.md, andclose-out.md/close-out-template.md(the per-slice report every agent writes its out-of-scope observations to) beside it, plusproject-contract.md,preflight.mdandspec-tree.md(the rule for every commit into the shared spec tree and for citing a line).- Fieldnotes — a cross-project observation store
beside the workflow, in a repo of its own: agents post what they now leave in close-out reports,
and a scheduled reconciler curates it into a triage doc. It is developed in a KubeCoder environment
of its own, with its design note and slices in
pvginkel/FieldnotesAppSpecs. CHANGELOG-workflow.md— the plugin's changelog.