The exhaustive index of every article in this wiki, one section per ontology namespace. New to the wiki? Start at the introduction instead — it explains what these namespaces mean and suggests where to begin.

Sections mirror the eight ontology namespaces — five in the process layer (framework / capability / sdlc-stage / artifact / pattern), the harness layer (the agent program), the runtime execution layer, the store state layer, and the registry supply layer. A final topic section holds curated cross-cutting overlays (Maps of Content) that sit above the ontology graph. Schema & ontology: see CONVENTIONS.

framework

Complete SDLC agent toolkits / methodologies (e.g. GSD, SpecKit, OpenSpec).

ArticleSummaryUpdated
gsdGit. Ship. Done. — context-engineering, spec-driven five-phase loop (Discuss→Plan→Execute→Verify→Ship) for AI coding agents; solves context rot via fresh-context subagents.2026-07-04
matt-pocock-skillsMatt Pocock’s “Skills for Real Engineers” (v1.3.1, 2026-10-04): a loose, composable toolkit (37 skills; Claude Code plugin + skills.sh, Codex metadata) that stays small because it refuses to own the process (vs GSD/BMAD/Spec-Kit). Addresses four AI-coding failure modes; a documented main flow via /ask-matt, now **grill→to-spec→to-tickets→implementimplement-spec→code-review→pr→retro**. v1.2–1.3 added implement-spec (parallel frontier), pr (release, partial), retro (first stage-learn capability), to-questionnaire, wizard, wait-what, writing-for-agents; removed resolving-merge-conflicts and the v1.1 deprecations; renamed CONTEXT.md→GLOSSARY.md. Touches 7 of 8 stages (no Validate).
addy-agent-skillsAddy Osmani’s “Agent Skills” — 24 skills + 4 review personas + 8 commands organizing the whole lifecycle (Define→Plan→Build→Verify→Review→Ship); anti-rationalization guards, parallel persona fan-out. Broadest framework here.2026-07-04
openspecFission AI’s “OpenSpec” — spec-driven development for AI assistants; fluid/brownfield-first. Explore→Propose→Apply→Verify→Archive. Signature: a living specification maintained by ADDED/MODIFIED/REMOVED deltas. Its “release” is spec-merge, not deploy.2026-07-04
speckitGitHub’s “Spec Kit” — the reference implementation of spec-driven development (Spec→Plan→Tasks→Implement) across 30+ agents. Signature: a project constitution of immutable principles that gate every plan/analysis; TDD non-negotiable. Largest community (106K★). No release/deploy step.2026-07-04
bmadBMAD-METHOD (v6) — “Breakthrough Method for Agile AI-Driven Development.” The most role-oriented & lifecycle-complete framework here: six named expert personas (Analyst/PM/Architect/Dev…) facilitate a scale-adaptive Analysis→Planning→Solutioning→Implementation pipeline. Signatures: persona agents + Party Mode, scale-adaptive ceremony, context-engineered story files. Deepest align/specify front-end; no deploy step (closes with a retrospective). ~50K★.2026-07-04
compound-engineeringEvery’s “Compound Engineering” (Shipper & Klaassen) — coding when agents write ~100% of the code. A self-feeding six-step loop (Brainstorm→Plan→Work→Simplify→Review→Compound) + autonomous /lfg. 80/20 planning-review split. Signature: knowledge compounding — learnings captured to docs/solutions/ and re-read by future agents. The only framework here whose lifecycle is a loop; promotes the new 7th canonical stage, stage-learn. ~22.6K★.2026-07-04
gstackGarry Tan’s (YC CEO) “gstack” — turns Claude Code into a virtual engineering team. The largest framework here (~54 skills), organized as a full sprint Think→Plan→Build→Review→Test→Ship→Reflect. Signatures: role personas (CEO/eng/designer/QA/CSO/SRE), a persistent browser daemon (“the eyes”), cross-model /codex second opinion, safety guardrails (careful/freeze/guard), and knowledge compounding (/learn + gbrain). The first framework with a genuine deploy step (/land-and-deploy) + post-deploy /canary. Spans all 8 stages; its clean Review∥Test partition promoted the new stage-review (with Addy), and it is a 3rd framework for stage-learn. MIT.
bm-skillsBrian Casel’s (Builder Methods) “BM Skills” — a Claude Code plugin marketplace of small independent builder utilities; deliberately not a full-SDLC framework. Three skills: PRD Creator (the focus — a non-technical-builder interview → visual HTML PRD + milestone prompts), Design System scaffolder, Favicon Creator. Only PRD Creator maps to a canonical stage (specify).2026-07-09
superpowersJesse Vincent’s (Prime Radiant) “Superpowers” — a complete methodology from a deliberately small library (14 skills, no personas, no commands, no deploy). A bootstrap skill (sp-using-superpowers) makes the rest auto-trigger (“if there’s even a 1% chance a skill applies, you MUST use it”), turning 14 skills into a mandatory gated pipeline (brainstorm→worktree→plan→subagent-driven→TDD→review→finish). Co-signature of pattern-anti-rationalization (Iron Laws + Red Flags everywhere); unusually cross-harness (Claude Code/Codex/Cursor/Kimi/OpenCode/Pi/…). Novel contributions: receiving-code-review (the review-reception side no one else pages) and verification-before-completion (pattern-evidence-before-claims). Touches 7 stages (no specify). MIT, v6.1.1.2026-07-17
nano-specTao An’s “nano-spec” — “Spec-driven thinking, nano-sized docs.” A deliberately minimal, tool-agnostic task-spec methodology (MIT, 46★); not a full-SDLC framework. One /nano-spec skill (create/status/update) generating a fixed 4-document pack per task (README/todo/doc/log) across 10 agents. The 8th member of the specify cluster — the minimalist pole (opposite gated maximalists like SpecKit/gstack and OpenSpec’s living spec); embodies scale-adaptive planning as a fixed middle tier on a no-spec→nano→full-spec spectrum. Only create maps to a canonical stage (specify).2026-07-13
agent-osBrian Casel’s (Builder Methods) Agent OS v3.0.0 — “Agents that build the way you would.” A deliberately narrow, non-full-SDLC framework: a durable guide layer (project standards + product docs) plus the front of the lifecycle (align + specify), handing build/review/validate/ship to the coding agent. Five commands, no sub-agents. v3 is a rare shrink — it deleted its own v2 scaffolding once Plan Mode + better models made it derivable, keeping only the non-derivable convention layer. The wiki’s purest instance of guides (feedforward); standards refined via bidirectional profile-sync (pattern-knowledge-compounding). MIT, ~5.2K★.2026-08-05

| pstack | Lauren Tan’s (poteto, Cursor / React core) pstack v0.15.2 — “if you want to go fast, go deep first.” A Cursor-native plugin (25 skills, 23 one-rule principle skills, 2 subagents, 23 playbooks, a dormant automation pack) whose thesis is that rigor is the precondition for parallelism, not a tax on it. Signatures: a sticky mode router with every leaf skill manual; model diversity instead of personas for review; a five-rung evidence ladder; the organizational record as a research corpus (7 MCP-discovered sources). Mints pattern-candidate-grafting, pattern-tooling-leverage, pattern-idempotent-operations, artifact-decision-log. Ships no specify stage by stated principle (“the best spec is code”) and no release beyond opening a PR. First framework here with an empty runs_on: — Cursor has no harness page yet. MIT. | 2026-09-26 | | builder-skills | Builder.io’s BuilderIO/skills: 24 skills and one command. Its centrepiece is the experimental Factory, nine skills that turn feedback, telemetry, errors, and PR queues into policy-gated changes and that ship only instructions, borrowing scheduler, connectors, worktrees, and credentials from the host. That makes it the wiki’s first prompt-owned control plane (the 🧩 pole of topic-software-factory), filed as a framework because it spawns nothing. Signatures: ten independently authorized actions with no inference between them (pattern-action-gating, new), head-bound evidence with a soak, unavailable ≠ truncated ≠ empty, a read-only human-decision queue, and production-signal lookbacks (a third flavor of stage-learn). The other 15 skills cover cross-agent review (agent-watchdog, plan-arbiter), autonomy (plow-ahead), cost-tiered orchestration (pattern-model-tiering, new), docs-first discipline, status recaps, and Agent-Native app front-ends. Mints artifact-autonomy-policy. No specify or validate stage. MIT. | 2026-09-26 |

capability

Individual commands, skills, and sub-agents a framework, store, or registry ships (subtype: distinguishes; belongs_to: names the owner). Store and registry capabilities — the seeds-*, beads-*, and tessl-* rows — mostly implement no lifecycle stage, which is the expected shape for those layers rather than a gap.

ArticleSummaryUpdated
gsd-discuss-phaseGSD command — Phase 1; adaptive questioning to lock decisions → CONTEXT.md.2026-07-04
gsd-plan-phaseGSD command — Phase 2; research, atomic plan, eight-dimension verification loop → PLAN.md.2026-07-04
gsd-execute-phaseGSD command — Phase 3; wave-based parallel execution via fresh-context executors.2026-07-04
gsd-verify-workGSD command — Phase 4; conversational UAT with auto-diagnosis → UAT.md.2026-06-27
gsd-shipGSD command — Phase 5; push branch, open PR, track merge, archive phase.2026-09-26
gsd-phase-researcherGSD sub-agent — four parallel domain-research instances → RESEARCH.md.2026-06-27
gsd-plannerGSD sub-agent — Opus-tier atomic plan author → PLAN.md.2026-09-26
gsd-plan-checkerGSD sub-agent — eight-dimension plan gate, up to three revisions.2026-06-27
gsd-executorGSD sub-agent — sole Edit-capable agent; one atomic commit per task.2026-06-27
gsd-verifierGSD sub-agent — goal-backward analysis after execution.2026-06-27
gsd-debuggerGSD sub-agent — evidence-tracking bug investigation; clusters with mp-diagnosing-bugs + addy-debugging.2026-07-04
mp-grill-meMP skill — comprehensive interview on a plan/design until decisions resolve.2026-07-04
mp-grillingMP skill (model-invoked) — the reusable interview loop behind the grill skills (v1.1: confirmation gate + facts-vs-decisions; v1.2.0: round-by-round over the question frontier, facts to background sub-agents).2026-10-11
mp-grill-with-docsMP skill — grilling that builds a domain model (GLOSSARY.md, was CONTEXT.md) + ADRs; the default entry whenever you are in a working directory.2026-10-11
mp-to-specMP skill — synthesize a conversation into a spec → artifact-spec-md (v1.1: renamed from to-prd; “spec” is the through-line term); specify cluster.2026-07-09
mp-to-ticketsMP skill — break a plan/spec into tracer-bullet tickets with blocking edges (v1.1: to-issues + to-plan merged); handles wide refactors via expand–contract. v1.2.0: one file per ticket locally; the task graph mp-implement-spec schedules from.2026-10-11
mp-domain-modelingMP skill (model-invoked) — build/sharpen the project domain model + ubiquitous language (v1.1: absorbed ubiquitous-language; v1.3.0: CONTEXT.md → GLOSSARY.md).2026-10-11
mp-codebase-designMP skill (model-invoked) — design deep modules with small interfaces; clusters with addy-api-design.2026-07-04
mp-tddMP skill (model-invoked) — test-first red → green loop (v1.1: reference-only; refactor moved to mp-code-review; “seam” leading word).2026-07-09
mp-prototypeMP skill (model-invoked) — throwaway prototype for a design question; v1.2.0: a single shareable HTML file, kept as a primary source on a prototype/<name> branch rather than deleted.2026-10-11
mp-diagnosing-bugsMP skill (model-invoked) — reproduce→minimize→hypothesize→instrument→fix; clusters with gsd-debugger + addy-debugging. v1.2.3 redacts secrets; v1.3.x routes a post-fix /retro.2026-10-11
mp-improve-codebase-architectureMP skill — scan for deepening opportunities; HTML report, then grill one; v1.2.0 YAGNI-scopes to recently changed paths (review).2026-10-11
mp-handoffMP skill — compact a conversation into a handoff document; v1.2.0 narrowed to when context must travel (new harness/directory/colleague/mid-phase fork).2026-10-11
mp-implementMP skill — build the work from a spec/tickets per ticket; drives mp-tdd at seams, closes with mp-code-review, commits; execute cluster (implement). Parallel sibling: mp-implement-spec.2026-10-11
mp-code-reviewMP skill — two-axis diff review: Standards (+ Fowler smell baseline) ∥ Spec, parallel sub-agents (v1.1, graduated from in-progress); code-review cluster (review). v1.3.0: runs once per ticket (implement) or once over the integration branch (implement-spec); standards tuned by mp-retro.2026-10-11
mp-researchMP skill — background agent investigating primary sources → cited Markdown → artifact-research-md (v1.1, new); counterpart to gsd-phase-researcher (plan).2026-07-09
mp-wayfinderMP skill — map work too big for one session as a shared map of decision tickets on the tracker (v1.2.0 rename); research burned down by parallel subagents; hands off at to-spec; scale-adaptive (align).2026-10-11
mp-resolving-merge-conflictsRemoved in v1.3.0 (nothing replaces it). Was: MP skill resolving an in-progress merge/rebase from each side’s primary-source intent (implement). Kept as a historical page.2026-10-11
mp-triageMP skill — move issues/PRs through a triage state machine → agent-ready briefs (newly paged; intake, align); counterpart to ce-sweep.2026-09-26
mp-ask-mattMP router — “which skill fits?”; main flow idea→grill→to-spec→to-tickets→implementimplement-spec→code-review→pr→retro, three on-ramps, and a five-option phase-boundary tree (v1.2.0); counterpart to addy-using-agent-skills + gstack-router.
mp-implement-specMP skill (v1.3.0) — implement a whole spec in one run: tickets as a task graph, implementer subagents in their own worktrees across the ready frontier, one integration branch, one closing code-review; parallel-execute cluster with gsd-execute-phase + sp-subagent-driven-development + pstack-swarm (implement).2026-10-11
mp-prMP skill (model-invoked, v1.3.0) — the shape of a PR body: smallest-visual Summary, before/after Evidence, Merge Danger (one-/two-way door + blast radius); body only, no push/merge (release, partial).2026-10-11
mp-retroMP skill (v1.3.0) — session retrospective that suggests environment changes (pointers, checks, standards, steering, tooling); mechanical findings → deterministic checks. MP’s first stage-learn capability (environment-compounding flavor); counterpart to pstack-reflect + ce-compound.2026-10-11
mp-to-questionnaireMP skill (v1.2.0) — turn a decision you can’t answer into a Markdown questionnaire for the one person who can; grills the send, not the subject (align, delegated-elicitation flavor).2026-10-11
mp-wizardMP skill (model-invoked, v1.2.0) — generate an interactive bash wizard for steps only a human can perform (provisioning, credentials/CI secrets, dashboards, cutovers) from a fixed template.sh library (no stage).2026-10-11
mp-wait-whatMP skill (v1.2.0) — three-line corrective: re-pitch the last message with context, in Simplified Technical English, using the GLOSSARY.md vocabulary (no stage).2026-10-11
mp-writing-for-agentsMP skill (model-invoked, v1.2.0; renamed from writing-great-skills) — reference for writing any agent-facing doc: context pointers, the two loads, information hierarchy, leading words, pruning (no stage); counterpart to sp-writing-skills.2026-10-11
bm-prd-creatorBM Skills — PRD Creator: structured interview for non-technical builders → visual HTML/markdown PRD + milestone prompt files; specify cluster (7-framework); what-not-how boundary (specify).2026-07-09
bm-design-systemBM Skills — scaffold a React + Tailwind v4 design system (live reference page + shadcn components + AGENTS.md guardrails); counterpart to addy-frontend-ui (implement).2026-07-09
bm-favicon-creatorBM Skills — generate a full favicon set from a Lucide icon/SVG and wire the meta tags; pure asset utility (no stage).2026-07-09
addy-using-agent-skillsAddy meta-skill — routes incoming work to the right skill; shared operating rules.2026-07-04
addy-interview-meAddy skill — one-question-at-a-time interview to ~95% intent confidence; grilling cluster.2026-07-04
addy-idea-refineAddy skill — divergent/convergent ideation turning vague ideas into concrete proposals.2026-07-04
addy-spec-driven-developmentAddy skill — write a six-area SPEC.md before code; the pair (with mp-to-spec) that promoted stage-specify.2026-07-04
addy-planningAddy skill — decompose a spec into small, verifiable, dependency-ordered tasks.2026-07-04
addy-incremental-implementationAddy skill — thin vertical slices: implement, test, verify, commit; feature flags.2026-07-04
addy-tddAddy skill — Red-Green-Refactor + Prove-It for bugs; third framework in the TDD cluster.2026-07-04
addy-context-engineeringAddy skill — feed the right context at the right time (rules files, packing, MCP).2026-07-04
addy-source-driven-developmentAddy skill — ground decisions in cited official docs; flag the unverified.2026-09-26
addy-doubt-driven-developmentAddy skill — in-flight adversarial fresh-context review (CLAIM→EXTRACT→DOUBT→RECONCILE→STOP).2026-07-04
addy-frontend-uiAddy skill — production-quality UI; design systems; WCAG 2.1 AA accessibility.2026-07-04
addy-api-designAddy skill — contract-first interfaces; Hyrum’s Law; One-Version Rule; clusters with mp-codebase-design.2026-07-04
addy-browser-testingAddy skill — live runtime data via Chrome DevTools MCP.2026-07-04
addy-debuggingAddy skill — five-step triage (reproduce, localize, reduce, fix, guard); debugging cluster.2026-07-04
addy-code-reviewAddy skill — five-axis review with severity labels + change sizing → review report.2026-09-26
addy-code-simplificationAddy skill — reduce complexity while preserving exact behavior (Chesterton’s Fence, Rule of 500).2026-07-04
addy-securityAddy skill — OWASP Top 10 hardening; auth; secrets; dependency auditing.2026-07-04
addy-performanceAddy skill — measure-first; Core Web Vitals; profiling; bundle analysis.2026-07-04
addy-git-workflowAddy skill — trunk-based dev; atomic commits; semver; changelogs.2026-07-04
addy-ci-cdAddy skill — Shift Left; feature flags; quality-gate pipelines.2026-07-04
addy-deprecationAddy skill — code-as-liability; compulsory vs advisory deprecation; zombie-code removal.2026-07-04
addy-documentationAddy skill — ADRs + API/inline docs; document the why.2026-07-04
addy-observabilityAddy skill — structured logging; RED metrics; OpenTelemetry; symptom-based alerting.2026-07-04
addy-shippingAddy skill — pre-launch checklist; staged rollout; rollback; the /ship persona fan-out; clusters with gsd-ship.2026-09-26
addy-code-reviewerAddy sub-agent — Staff-Engineer five-axis review persona (in the /ship fan-out).2026-07-04
addy-test-engineerAddy sub-agent — QA persona: coverage analysis + Prove-It (in the /ship fan-out).2026-07-04
addy-security-auditorAddy sub-agent — security-engineer persona: threat model + OWASP (in the /ship fan-out).2026-07-04
addy-web-performance-auditorAddy sub-agent — Core Web Vitals audit persona; Quick/Deep modes; run via /webperf.2026-07-04
openspec-exploreOpenSpec command — investigate the codebase & compare approaches before committing; brownfield entry point (→ stage-align).2026-07-04
openspec-proposeOpenSpec command — generate all planning artifacts (proposal + spec deltas + design + tasks) in one step; specify-cluster with mp-to-spec + addy-spec-driven.2026-07-04
openspec-applyOpenSpec command — implement the tasks.md checklist sequentially, resuming from checkpoints; execute-cluster with gsd-execute-phase + addy-incremental.2026-07-04
openspec-verifyOpenSpec command — validate implementation vs spec artifacts (completeness/correctness/coherence); advisory, non-blocking (→ stage-validate).2026-07-04
openspec-syncOpenSpec command — merge a change’s spec deltas into the living main specs (RENAMED→REMOVED→MODIFIED→ADDED); the living-spec mechanism.2026-07-04
openspec-archiveOpenSpec command — finalize a completed change: optionally sync, then move to archive/; finalize-cluster with gsd-ship + addy-shipping.2026-09-26
speckit-constitutionSpec Kit command — establish immutable project governing principles (constitution.md); signature capability, no cross-framework counterpart. Governance flavor of align; parks stage-govern.2026-07-04
speckit-specifySpec Kit command — define WHAT/WHY as spec.md with user stories + [NEEDS CLARIFICATION] markers; four-framework specify cluster (mp-to-spec + addy-spec-driven + openspec-propose).2026-07-04
speckit-clarifySpec Kit command — iterative Q&A resolving the spec’s [NEEDS CLARIFICATION] markers; grilling cluster (spec-first ordering variant).2026-07-04
speckit-planSpec Kit command — technical plan + design (plan.md/data-model.md/contracts/) + research, gated against the constitution; clusters with gsd-plan-phase; applies contract-first.2026-07-04
speckit-tasksSpec Kit command — decompose the plan into a [P]-parallelizable, test-first task list (tasks.md); decompose cluster with mp-to-tickets + addy-planning.2026-07-04
speckit-analyzeSpec Kit command — cross-artifact consistency & coverage gate vs the constitution; plan-verification cluster with gsd-plan-checker (now two-framework).2026-07-04
speckit-implementSpec Kit command — execute tasks.md with TDD “NON-NEGOTIABLE”; execute cluster with gsd-execute + openspec-apply + addy-incremental.2026-07-04
speckit-checklistSpec Kit command — generate a quality checklist validating requirements (“unit tests for your English”) → artifact-checklist; spec-quality gate, no counterpart.2026-07-04
speckit-convergeSpec Kit command — assess codebase vs spec/plan/tasks and append the gap as new tasks; validate cluster with openspec-verify but action-oriented (re-plans, not just reports).2026-07-04
speckit-taskstoissuesSpec Kit command — export tasks.md to GitHub issues; equivalent to mp-to-tickets (export half).2026-07-04
bmad-analystBMAD sub-agent — Mary 📊, the Analysis persona; dispatches brainstorming/research/brief/PRFAQ/document-project (→ stage-align).2026-07-04
bmad-tech-writerBMAD sub-agent — Paige 📚; documentation-as-context-engineering persona; owns document-project.2026-07-04
bmad-pmBMAD sub-agent — John 📋, the Planning persona; owns PRD, epics/stories, readiness, correct-course (→ stage-specify).2026-07-04
bmad-ux-designerBMAD sub-agent — Sally 🎨; UX persona; produces the DESIGN.md + EXPERIENCE.md spec.2026-07-04
bmad-architectBMAD sub-agent — Winston 🏗️, the Solutioning persona; produces the architecture spine (→ stage-plan).2026-07-04
bmad-devBMAD sub-agent — Amelia 💻, the Implementation persona; absorbed SM + QA; owns create-story/dev/review/sprint/retro (→ stage-implement).2026-07-04
bmad-brainstormingBMAD skill — diverge-then-converge ideation; clusters with addy-idea-refine.2026-07-04
bmad-forge-ideaBMAD skill — adversarially pressure-test an idea until it hardens or dies cheaply.2026-07-04
bmad-researchBMAD skill — market/domain/technical research up front in Analysis → artifact-research-md.2026-07-04
bmad-product-briefBMAD skill — pre-PRD scoping brief → artifact-product-brief.2026-07-04
bmad-prfaqBMAD skill — Amazon Working-Backwards PRFAQ stress-test → artifact-product-brief.2026-07-04
bmad-document-projectBMAD skill — brownfield codebase documentation for AI context; clusters with openspec-explore.2026-07-04
bmad-prdBMAD skill — the facilitated create/update/validate PRD; fifth framework in the specify cluster → artifact-prd.2026-07-04
bmad-uxBMAD skill — two-spine UX design spec (DESIGN.md visual + EXPERIENCE.md behavioral) → artifact-design-md.2026-07-04
bmad-specBMAD skill — the five-field SPEC kernel; Quick-Flow lightweight spec → artifact-spec-md.2026-07-04
bmad-architectureBMAD skill — the invariants-only architecture spine → artifact-architecture.2026-07-04
bmad-create-epics-and-storiesBMAD skill — decompose requirements into epics of context-rich stories; decompose cluster → artifact-story.2026-07-04
bmad-check-implementation-readinessBMAD skill — PASS/CONCERNS/FAIL readiness gate over PRD+UX+arch+epics; promotes plan-verification to three frameworks.2026-07-04
bmad-sprint-planningBMAD skill — generate sprint-status.yaml, the story-loop state file.2026-07-04
bmad-create-storyBMAD skill — author the context-filled story spec; the plan→implement bridge → artifact-story.2026-07-04
bmad-dev-storyBMAD skill — implement one fully-contexted story test-first in fresh context; sixth framework in the execute cluster.2026-07-04
bmad-quick-devBMAD skill — Quick-Flow fast path (+ bmad-dev-auto unattended); the scale-adaptive shortcut.2026-07-04
bmad-code-reviewBMAD skill — adversarial parallel review layers in fresh context; clusters with addy-code-review → artifact-review-report.2026-09-26
bmad-correct-courseBMAD skill — mid-flight re-planning valve for scope changes; relates to speckit-converge.2026-07-04
bmad-retrospectiveBMAD skill — post-epic Party-Mode learning close-out; moved 2026-07-04 from stage-release to the new stage-learn (co-evidence with ce-compound).2026-07-04
ce-strategyCE skill — maintain STRATEGY.md, the upstream anchor ideate/brainstorm/plan read → artifact-strategy-md (align).2026-07-04
ce-ideateCE skill — conceptual-frame + adversarial-filter idea discovery; clusters with bmad-brainstorming + addy-idea-refine (align).2026-07-04
ce-povCE skill — decisive Adopt/Trial/Hold/Reject verdict on external inputs, dual-grounded (align).2026-07-04
ce-brainstormCE skill — requirements-only dialogue → artifact-brainstorm-md; grilling cluster (align).2026-07-04
ce-sweepCE skill — consolidate Slack/GitHub feedback into next-cycle inputs (align, feedback-intake).2026-09-26
ce-planCE skill — enrich requirements into guardrail plans (U-IDs + test scenarios, WHAT-not-HOW) → artifact-plan-md; plan cluster (plan).2026-07-04
ce-doc-reviewCE skill — persona fan-out over requirements/plans before code; plan-verification cluster, now four-framework (plan).2026-07-04
ce-workCE skill — execute the guardrailed plan in worktree isolation; seventh member of the execute cluster (implement).2026-07-04
ce-worktreeCE skill — ensure work runs in an isolated git worktree; signature pattern-worktree-isolation (implement).2026-07-04
ce-debugCE skill — causal-chain root-cause with prediction-confirmation; debugging cluster (implement).2026-07-04
ce-polishCE skill — conversational UX iteration against a live dev server (implement).2026-07-04
ce-simplify-codeCE skill — reduce complexity in fresh code, behavior-preserving; direct counterpart to addy-code-simplification (review).2026-07-04
ce-code-reviewCE skill — ~16-persona confidence-gated review, adversarial + cross-model → artifact-review-report; code-review cluster (review).2026-09-26
ce-optimizeCE skill — metric-driven, parallel-experiment optimization; counterpart to addy-performance (review).2026-07-04
ce-test-browserCE skill — diff-scoped end-to-end browser tests; counterpart to addy-browser-testing (validate).2026-07-04
ce-test-xcodeCE skill — iOS simulator build/test via XcodeBuildMCP; the wiki’s only native-iOS validator (validate).2026-07-04
ce-dogfoodCE skill — autonomous, self-fixing diff-scoped browser QA (validate, pattern-autonomous-loop).2026-07-04
ce-commitCE skill — one convention-aware atomic commit → artifact-atomic-commit; clusters with addy-git-workflow (release).2026-07-04
ce-commit-push-prCE skill — working changes → open PR → artifact-pull-request; finalize cluster with gsd-ship/addy-shipping (release).2026-09-26
ce-resolve-pr-feedbackCE skill — evaluate/fix/reply to PR review feedback in parallel (release, pre-merge).2026-09-26
ce-promoteCE skill — draft user-facing launch announcements across channels (release, announce).2026-07-04
ce-product-pulseCE skill — time-windowed post-release usage/perf/error report (release, operate/monitor).2026-07-04
ce-compoundCE skill — the money step: mine completed work → docs/solutions/ (artifact-solution-doc); promoted stage-learn (learn).2026-07-04
ce-compound-refreshCE skill — maintain the solution corpus (Keep/Update/Consolidate/Replace/Delete) (learn).2026-07-04
ce-explainCE skill — dense visual explainers of concepts/diffs → artifact-explainer; human-facing learning (learn).2026-07-04
lfgCE command — autonomous full pipeline plan→work→simplify→review→commit→PR→green CI (orchestrator, plan–release).2026-07-04
ce-repo-profilerCE sub-agent — question-agnostic cached project profile reused across all grounding skills (align).2026-07-05
ce-learnings-researcherCE sub-agent — reads the docs/solutions/ corpus back into new work; the consuming side of knowledge-compounding (align).2026-07-05
ce-slack-researcherCE sub-agent — org-knowledge digest from Slack (align).2026-07-05
ce-web-researcherCE sub-agent — external grounding digest for ideation (align).2026-07-05
ce-issue-intelligence-analystCE sub-agent — theme-level (not ticket-level) issue-tracker intelligence (align).2026-07-05
ce-external-evidence-researcherCE sub-agent — verified external evidence for ce-pov verdicts; gathers, never recommends (align).2026-07-05
ce-precedent-activity-scoutCE sub-agent — prior-decision precedent + incumbent pain for ce-pov (align).2026-07-05
ce-project-grounding-scoutCE sub-agent — this-codebase floor for ce-pov verdicts (align).2026-07-05
ce-media-analyzerCE sub-agent — turns feedback media (Riffrec/video) into a bug-shaped finding inside ce-sweep (align).2026-07-05
ce-agent-native-planning-strategistCE sub-agent — decides whether agents are first-class users, feeds plan inputs (plan).2026-07-05
ce-architecture-strategistCE sub-agent — reviews changes for architectural alignment/integrity; relates to bmad-architect (plan).2026-07-05
ce-spec-flow-analyzerCE sub-agent — surfaces missing flows/edge-cases pre-implementation; plan-verification lens (plan).2026-07-05
ce-git-history-analyzerCE sub-agent — repo archaeology (log/blame) as planning context (plan).2026-07-05
ce-data-migration-reviewerCE sub-agent — migration correctness + rollback, converted to plan requirements (plan).2026-07-05
ce-deployment-verification-agentCE sub-agent — launch-readiness checklist (artifact-launch-checklist) at plan time (plan).2026-07-05
ce-figma-design-syncCE sub-agent — pixel-perfect Figma↔code synchronization (implement).2026-07-05
ce-security-sentinelCE sub-agent — attacker-minded security audit → artifact-security-audit; counterpart to addy-security-auditor (review; also compound council).2026-07-05
ce-performance-oracleCE sub-agent — bottleneck analysis → artifact-perf-audit; counterpart to addy-web-performance-auditor (review; also compound council).2026-07-05
ce-pattern-recognition-specialistCE sub-agent — design/anti-pattern + recurring-problem analysis; core of compounding generalization (review/learn).2026-07-05
ce-data-integrity-guardianCE sub-agent — data-safety / migration-integrity / privacy review (review; also compound council).2026-07-05
ce-repo-research-analystCE sub-agent — repo research converted to optimization inputs (hot paths, metrics surfaces) for ce-optimize (review).2026-07-05
ce-pr-comment-resolverCE sub-agent — implements one orchestrator-validated PR-review fix in parallel (release).2026-07-05
ce-best-practices-researcherCE sub-agent — authoritative best-practice synthesis → enriches solution docs (learn; compound council).2026-07-05
ce-framework-docs-researcherCE sub-agent — framework/version docs as evidence for solution docs (learn; compound council).2026-07-05
ce-session-historianCE sub-agent — synthesizes lessons from prior agent sessions (Claude Code/Codex/Cursor/Pi) (learn; compound council).2026-07-05
ce-work-recap-scoutCE sub-agent — gathers recent-work evidence (git/PRs) for ce-explain’s explainer (learn).2026-07-05
gstack-routergstack root skill — routes work to the right specialist skill + proactive suggestions; counterpart to addy-using-agent-skills (meta/dispatcher, no stage).2026-07-05
gstack-office-hoursgstack command — YC Office Hours; reframe the product with six forcing questions → design doc that feeds the plan reviews; grilling cluster (align).2026-07-05
gstack-plan-ceo-reviewgstack command — CEO/founder plan review; find the 10-star product; four scope modes; persona panel (plan).2026-07-05
gstack-plan-eng-reviewgstack command — Eng-Manager plan review; lock architecture/data-flow/edge-cases/tests; plan-verification cluster, now five-framework (plan).2026-07-05
gstack-plan-design-reviewgstack command — Senior-Designer plan review; rate each design dimension 0-10 + AI-slop detection; boomerang of design-review (plan).2026-07-05
gstack-plan-devex-reviewgstack command — DX-Lead plan review; TTHW, personas, magical moment, friction traces; boomerang of devex-review (plan).2026-07-05
gstack-autoplangstack command — run the CEO→design→eng→DX review panel with auto-decisions + smart review routing; orchestrator (plan).2026-07-05
gstack-plan-tunegstack command — self-tune the plan reviews’ question sensitivity + developer psychographic (plan, meta).2026-07-05
gstack-design-consultationgstack command — build a complete design system from scratch → DESIGN.md; counterpart to bmad-ux (plan, design).2026-07-05
gstack-specgstack command — vague intent → five-phase executable spec; Codex quality gate; files a GitHub issue; —execute in a worktree; sixth framework in the specify cluster (specify).2026-07-05
gstack-design-shotgungstack command — generate 4-6 AI mockup variants + comparison board + taste memory → artifact-design-mockup (implement, design exploration).2026-07-05
gstack-design-htmlgstack command — turn an approved mockup into production Pretext-native HTML/CSS (implement).2026-07-05
gstack-investigategstack command — Iron-Law root-cause debugging (no fix without investigation; auto-freeze; stop after 3); debugging cluster (implement).2026-07-05
gstack-scrapegstack command — pull structured data from a web page via the browse daemon; compounds via skillify (implement).2026-07-05
gstack-carefulgstack command — warn before destructive commands; pattern-edit-guardrails (implement, safety).2026-07-05
gstack-freezegstack command — hard-lock edits to one directory; pattern-edit-guardrails (implement, safety).2026-07-05
gstack-guardgstack command — careful + freeze combined (implement, safety).2026-07-05
gstack-unfreezegstack command — clear the freeze boundary (implement, safety).2026-07-05
gstack-context-savegstack command — save working context + WIP checkpoint commits; session-handoff cluster with mp-handoff (implement).2026-07-05
gstack-context-restoregstack command — restore session state from saved context / WIP commits, across Conductor workspaces (implement).2026-07-05
gstack-reviewgstack command — Staff-Engineer pre-landing PR review; auto-fixes the obvious; code-review cluster → artifact-review-report (review).2026-09-26
gstack-codexgstack command — OpenAI Codex second opinion (review/challenge/consult); pattern-cross-model-review; also spec’s quality gate (review).2026-07-05
gstack-design-reviewgstack command — live visual audit + fix loop with atomic commits; boomerang of plan-design-review (review).2026-07-05
gstack-devex-reviewgstack command — live developer-experience audit; measures TTHW; boomerang of plan-devex-review (review).2026-07-05
gstack-csogstack command — Chief Security Officer; OWASP Top 10 + STRIDE with exploit scenarios → artifact-security-audit; security cluster (review).2026-07-05
gstack-healthgstack command — standing code-quality dashboard (type/lint/tests/dead-code) (review).2026-07-05
gstack-qagstack command — real-browser QA that fixes bugs + generates a regression test per fix; browser-testing cluster; pattern-autonomous-loop (validate, Test).2026-07-05
gstack-qa-onlygstack command — same QA methodology, report-only (no code changes) (validate, Test).2026-07-05
gstack-benchmarkgstack command — Core Web Vitals / load regression benchmark before/after per PR → artifact-perf-audit; performance cluster (review).2026-07-05
gstack-ios-qagstack command — live-device iOS QA over USB/Tailscale; counterpart to ce-test-xcode but real hardware (validate, Test).2026-07-05
gstack-ios-fixgstack command — autonomous iOS bug fixer with regression-snapshot capture (validate, Test).2026-07-05
gstack-ios-design-reviewgstack command — designer’s-eye iOS audit on real hardware; 10-dim Apple HIG rubric (review).2026-07-05
gstack-ios-syncgstack command — regenerate the iOS debug-bridge accessors for ios-qa (validate, enabling).2026-07-05
gstack-browsegstack command — persistent headless-Chromium daemon (“the eyes”) behind live QA/audit skills (validate, enabling infra).2026-07-05
gstack-open-gstack-browsergstack command — visible GStack Browser with sidebar + anti-bot stealth + auto model routing (validate, enabling).2026-07-05
gstack-setup-browser-cookiesgstack command — import real-browser cookies into the headless session for authenticated testing (validate, enabling).2026-07-05
gstack-pair-agentgstack command — pair a cross-vendor AI agent with your browser (scoped tokens, tab isolation); novel, no counterpart (implement, collaboration).2026-07-05
gstack-shipgstack command — Release Engineer; test, review, bump VERSION+CHANGELOG, commit, push, open PR; finalize cluster → artifact-pull-request (release).2026-09-26
gstack-land-and-deploygstack command — merge PR, wait for CI + deploy, verify production health; the first genuine deploy step in the wiki (release, deploy).2026-07-05
gstack-canarygstack command — SRE post-deploy monitoring loop; counterpart to ce-product-pulse (release, operate/monitor).2026-07-05
gstack-landing-reportgstack command — read-only dashboard for the workspace-aware ship queue (release).2026-07-05
gstack-document-releasegstack command — post-ship doc update + Diataxis coverage map → artifact-diataxis-docs; auto-invoked by ship (release, docs).2026-07-05
gstack-document-generategstack command — generate missing Diataxis docs from code → artifact-diataxis-docs (release, docs).2026-07-05
gstack-setup-deploygstack command — one-time deploy-config detection for land-and-deploy (release, enabling).2026-07-05
gstack-ios-cleangstack command — strip DebugBridge + if DEBUG wiring before a Release build (release, enabling).2026-07-05
gstack-retrogstack command — team-aware weekly retrospective → artifact-retrospective; counterpart to bmad-retrospective; team-process flavor of learn (learn).2026-07-05
gstack-learngstack command — manage the cross-session learnings corpus → artifact-solution-doc; agent-grounding flavor; counterpart to ce-compound (learn).2026-07-05
gstack-skillifygstack command — codify a successful scrape into a permanent browser-skill; capability-compounding (learn).2026-07-05
gstack-setup-gbraingstack command — set up gbrain persistent cross-machine memory (PGLite/Supabase/remote MCP) (learn, enabling).2026-07-05
gstack-sync-gbraingstack command — re-index repo code into gbrain + write CLAUDE.md search guidance; pattern-context-engineering (learn, enabling).2026-07-05
gstack-diagramgstack command — English/mermaid → diagram triplet (mermaid + editable .excalidraw + SVG/PNG), offline (cross-cutting utility, no stage).2026-07-05
gstack-make-pdfgstack command — markdown → publication-quality PDF (renders mermaid/excalidraw), —to htmldocx (cross-cutting utility, no stage).
gstack-benchmark-modelsgstack command — cross-model benchmark of gstack’s own skills (Claude/GPT/Gemini); meta-tooling (no stage).2026-07-05
gstack-upgradegstack command — self-updater (global vs vendored install); meta-tooling (no stage).2026-07-05
nano-spec-createnano-spec command — generate the minimal 4-document pack (README/todo/doc/log) from a one-line description; the 8th specify-cluster member, minimalist/tool-agnostic (specify).2026-07-13
nano-spec-statusnano-spec command — read todo.md+log.md and report progress (done vs total, blockers, last-log date); read-only status surface; session-handoff (no stage).2026-07-13
nano-spec-updatenano-spec command — apply a change to the pack and append a dated log.md entry; keeps the spec a living, handoff-ready doc through the build (no stage).2026-07-13
sp-using-superpowersSuperpowers skill — the session-start bootstrap that forces skill invocation before any action (“1% chance → you MUST use it”); router + anti-rationalization gate (no stage). Counterpart to addy-using-agent-skills / gstack-router / mp-ask-matt.2026-07-17
sp-brainstormingSuperpowers skill — Socratic one-question-at-a-time design refinement; 2-3 approaches; design in sections; HARD-GATE before any code → artifact-design-md; grilling cluster (align).2026-07-17
sp-writing-plansSuperpowers skill — decompose an approved design into bite-sized (2-5 min) tasks with exact files, complete code, interfaces, verification; no placeholders; bakes the TDD loop into each task → artifact-plan-md; plan/decompose cluster (plan).2026-07-17
sp-subagent-driven-developmentSuperpowers skill — the recommended executor: fresh implementer subagent per task + two-stage task review (spec ∥ quality) + final whole-branch review; explicit model selection; durable ledger (implement).2026-07-17
sp-executing-plansSuperpowers skill — the parallel-session executor: batch execution with human checkpoints (subagent-free fallback); execute cluster (now eight-framework) (implement).2026-07-17
sp-test-driven-developmentSuperpowers skill — RED-GREEN-REFACTOR; Iron Law “no production code without a failing test first” (delete code written before its test); fourth+ TDD-cluster framework (implement).2026-07-17
sp-systematic-debuggingSuperpowers skill — four-phase root-cause process; Iron Law “no fixes without investigation”; question the architecture after 3 failed fixes; tightest counterpart gstack-investigate (implement).2026-07-17
sp-verification-before-completionSuperpowers skill — signature honesty gate: “no completion claims without fresh verification evidence” (pattern-evidence-before-claims); verifies the agent’s own claims, not spec-conformance; no counterpart (validate).2026-07-17
sp-requesting-code-reviewSuperpowers skill — dispatch a fresh-context reviewer subagent, act on findings by severity → artifact-review-report; code-review cluster (now six-framework) (review).2026-09-26
sp-receiving-code-reviewSuperpowers skill — how to respond to review: technical evaluation over performative agreement (“You’re absolutely right!” forbidden), verify-then-implement, reasoned pushback. Novel — the review-reception side no other framework pages (review).2026-07-17
sp-using-git-worktreesSuperpowers skill — ensure an isolated workspace: detect existing isolation → native tool → git-worktree fallback → clean-baseline check; counterpart to ce-worktree (pattern-worktree-isolation now two-framework) (implement).2026-07-17
sp-finishing-a-development-branchSuperpowers skill — verify tests → detect workspace → present exactly four options (merge / PR / keep / discard) → execute → clean up worktree; finalize cluster (now five-framework); no deploy → artifact-pull-request (release).2026-09-26
sp-dispatching-parallel-agentsSuperpowers skill — one focused subagent per independent problem domain, dispatched concurrently, then integrated; the concurrent-dispatch half of pattern-wave-parallelism (implement).2026-07-17
sp-writing-skillsSuperpowers skill — create/edit skills via TDD-for-documentation (baseline a subagent failing → write skill → watch it comply); the library grows itself → artifact-skill-doc; capability-compounding, ↔ gstack-skillify (learn).2026-07-17
agent-os-discover-standardsAgent OS command — mine the codebase’s tribal knowledge into concise standards, one “why”-interrogated file at a time; documents only unconventional patterns; seeds the sync-to-profile compounding loop (guide layer; no stage).2026-08-05
agent-os-index-standardsAgent OS command — maintain index.yml (standard → one-line description), the token-efficient matcher that lets standards load selectively instead of all-at-once (context-engineering plumbing; no stage).2026-08-05
agent-os-inject-standardsAgent OS command — deploy the relevant standards into context (auto-suggest or explicit), choosing file-reference vs embedded-snapshot payloads; the wiki’s purest pattern-context-engineering act (no stage).2026-08-05
agent-os-plan-productAgent OS command — one-question interview establishing the standing mission/roadmap/tech-stack docs → artifact-product-docs; counterpart to ce-strategy (align, product-direction flavor).2026-08-05
agent-os-shape-specAgent OS command — shape (not generate) a spec in Plan Mode into a persistent, timestamped pack with the matching standards bound in; the 9th specify-cluster member (specify).2026-08-05
seeds-initSeeds command — create .seeds/ and install the merge=union gitattributes that make the store mergeable.2026-08-31
seeds-createSeeds command — file one typed, prioritized unit of work → tracker issue; the low-ceremony tier of the planning dial.2026-08-31
seeds-showSeeds command — full detail for one or more issues, plan-aware (draft hint, approved children inline).2026-08-31
seeds-listSeeds command — filtered listing across five output formats, including ids for shell pipelines.2026-08-31
seeds-readySeeds command — the dispatch primitive: open issues with no unresolved blockers, plus schedule-aware and requires-plan gating.2026-08-31
seeds-searchSeeds command — substring search over title and description; the duplicate-avoidance step before filing.2026-08-31
seeds-updateSeeds command — mutate an issue; the --status in_progress claim is the whole coordination protocol between parallel agents.2026-08-31
seeds-closeSeeds command — close with a --reason; unblocks everything downstream.2026-08-31
seeds-depSeeds command — the dependency edges, stored on both endpoints; over-wiring hides work from sd ready.2026-08-31
seeds-blockSeeds command — the blocker-first surface over the same edges (block / unblock / blocked).2026-08-31
seeds-labelSeeds command — normalized tagging; also feeds plan-step label propagation and mulch domain inference.2026-08-31
seeds-statsSeeds command — project-level counts by status, type, and priority.2026-08-31
seeds-syncSeeds command — stage and commit .seeds/ locally; git is the tracker’s entire audit trail.2026-08-31
seeds-tplSeeds command — author convoy templates: a stored checklist, distinct from a plan template’s schema-for-reasoning.2026-08-31
seeds-tpl-pourSeeds command — instantiate a convoy template into a serially-wired chain of issues; decomposition as a macro.2026-08-31
seeds-tpl-statusSeeds command — convoy completion status, derived from the issues themselves.2026-08-31
seeds-plan-templatesSeeds command — list the plan templates (feature / bug / refactor, plus project-declared ones).2026-08-31
seeds-plan-promptSeeds command — emit the structured planning request, with mulch prior art pre-filling risks from past failures.2026-08-31
seeds-plan-submitSeeds command — the centre of gravity: AJV-validate the plan, spawn one child seed per step, wire the dependency edges → plan record.2026-08-31
seeds-plan-showSeeds command — plan sections, children, and recursive sub-plans; prints the (non-gating) review-suggested hint.2026-08-31
seeds-plan-validateSeeds command — re-run the gate against the current template, applying a tightened rule retroactively.2026-08-31
seeds-plan-listSeeds command — query plans by seed, status, outcome, or template; the only consumer of recorded outcomes.2026-08-31
seeds-plan-createSeeds command — an adopt-only plan with zero spawned children, for release trains.2026-08-31
seeds-plan-adoptSeeds command — link existing open seeds into a plan, link-only, never mutating their state.2026-08-31
seeds-plan-releaseSeeds command — detach a seed from a plan without closing it; the strict inverse of adopt.2026-08-31
seeds-plan-reorderSeeds command — pin the exact order of plan.children, which warren’s plan-run consumes verbatim as the schedule.2026-08-31
seeds-plan-editSeeds command — field-level plan fixes that propagate to child seeds and refresh their backref blocks.2026-08-31
seeds-plan-outcomeSeeds command — record success / partial / failure; the framework’s only Learn capability, deliberately storage-only.2026-08-31
seeds-plan-reviewSeeds command — record a reviewer’s name; informational, never gating. Maps to no stage.2026-08-31
seeds-doctorSeeds command — data-integrity and setup-drift checks with --fix; a deterministic gate over the store.2026-08-31
seeds-configSeeds command — typed config surface that publishes its own JSON Schema so warren can render a form; where plan templates are edited.2026-08-31
seeds-primeSeeds command — the tool emits its own rules into the agent’s context; context engineering inverted, because a CLI cannot be read like a SKILL.md.2026-08-31
seeds-onboardSeeds command — write the seeds section into CLAUDE.md / AGENTS.md; the persistent half of prime.2026-08-31
seeds-upgradeSeeds command — npm self-updater with --check; counterpart of gstack-upgrade.2026-08-31
seeds-completionsSeeds command — generated shell completions; the framework’s only human-facing capability.2026-08-31
seeds-migrate-from-beadsSeeds command — import .beads/issues.jsonl; cheap because seeds kept beads’ id format deliberately.2026-08-31
seeds-issue-workflowSeeds skill — the repo-local .factory/skills unit routing a vague ask between create-then-ready and plan-decomposition.2026-08-31
beads-readyThe dispatch primitive — the claimable frontier: open beads with no open blockers, excluding in-progress/blocked/deferred/gated; --claim is atomic.2026-08-31
beads-createFile a bead → tracker issue; content-hash ids so parallel branches never collide. Includes bd q quick capture and bd batch.2026-08-31
beads-updateThe mutation surface, incl. the atomic --claim; carries an orchestrator’s execution_* metadata without acting on it. bd edit is an agent trap.2026-08-31
beads-closeClose and reopen; closing releases blockers and lands as a Dolt commit with actor attribution.2026-08-31
beads-showBead detail plus audit trail, children, and per-bead version history.2026-08-31
beads-listFiltered listing, counts, blocked, stale — and bd orphans, which cross-references open beads against git commit messages.2026-08-31
beads-queryA small query language, text search, and semantic duplicate detection over a graph several agents append to.2026-08-31
beads-depFive typed edge kinds, only some of which gate work — provenance (discovered-from) and association (related) without hiding anything from the frontier.2026-08-31
beads-graphRender the dependency graph; bd graph check is a structural-integrity gate.2026-08-31
beads-epicEpic completion status and close-eligibility; hierarchy expressed in the id itself (bd-a3f8.1.1).2026-08-31
beads-swarmValidate an epic’s DAG and mint a swarm molecule “any coordinator agent” can pick up — the wave declared, the batching left to the layer above.2026-08-31
beads-supersedeThe knowledge-graph links (supersedes, duplicates, relates-to, replies-to) — meaning without schedulability.2026-08-31
beads-commentThreaded comments with per-actor attribution in the events journal; the substrate under message-type beads.2026-08-31
beads-labelLabels, including propagate from a parent to its children; the human and template labels carry semantics.2026-08-31
beads-todoSugar over task beads, existing to win one argument: “do not use markdown TODO lists for task tracking.”2026-08-31
beads-deleteDelete, prune, purge — the forgetting machinery a store that grows forever needs.2026-08-31
beads-formulaThe TOML/JSON DAG source for a repeatable workflow: steps, needs, variables, inheritance, gates. Shape only, never policy.2026-08-31
beads-cookCompile a formula into a proto; compile-time mode keeps {{variables}} intact so a work graph can be quoted before it is committed to.2026-08-31
beads-molPour a proto into real dependency-ordered beads (+ wisps, the ephemeral phase; squash/burn; distill extracts a formula from a finished epic). The one on-stage capability.2026-08-31
beads-gateAsync coordination as work items — a human sign-off, timer, or GitHub run becomes a blocking bead, “so agents never need to poll or spin.”2026-08-31
beads-merge-slotMutual exclusion on the merge to trunk, expressed as a bead you acquire and release.2026-08-31
beads-primeInject rules + memories at SessionStart, sized to the detected context budget (~50 tokens with MCP, ~1–2k without).2026-08-31
beads-rememberDurable insight as a store primitive, auto-primed every session; the README’s replacement for MEMORY.md files.2026-08-31
beads-kvA plain key-value store, for durable values rather than durable prose.2026-08-31
beads-compactTwo kinds of forgetting: semantic decay of old closed beads (context window) and Dolt history squashing (storage).2026-08-31
beads-doltThe storage-engine surface: remotes, push/pull on refs/dolt/data, embedded-vs-server lifecycle, raw SQL.2026-08-31
beads-vcVersion control over the work data — branch, merge, diff the issue graph alongside the code. No hosted tracker can do this.2026-08-31
beads-exportJSONL export/import for interchange — explicitly not the database, the sync protocol, or a backup.2026-08-31
beads-backupBackup destinations, sync, and restore; the runbook step before every destructive operation.2026-08-31
beads-federationPeer-to-peer sharing across repos and organizations, incl. a GCS/S3 bucket mode with no server to run.2026-08-31
beads-repoMulti-repo routing (contributor vs maintainer), cross-repo dependencies, and bd ship.2026-08-31
beads-initInitialize .beads/; three postures — default, --stealth (nothing committed), --contributor (planning routed elsewhere). Works without git.2026-08-31
beads-setupThirteen per-harness recipes that write beads into whichever file that harness reads and wire bd prime into its hooks.2026-08-31
beads-hooksGit hooks embedded in the binary: pre-commit lands Dolt changes with the code; post-merge carries a gated legacy JSONL fallback.2026-08-31
beads-configConfiguration with provenance (which value won, from where), plus a drift/apply convergence loop.2026-08-31
beads-doctorThe single consolidation point for health and remediation, incl. orphan detection and an intentional-divergence marker.2026-08-31
beads-lintA linter for work-item content — flags beads whose template sections are empty before anyone claims them.2026-08-31
beads-preflightA pre-PR checklist over the working tree, including stray .beads/issues.jsonl diffs.2026-08-31
beads-worktreeWorktree management wired to the store — the state-side half of worktree isolation.2026-08-31
beads-migrateSchema, hook, and sync migrations; the visible tax on choosing a real database (version guard, designated-clone protocol).2026-08-31
beads-upgradeVersion status and review-since-last-acknowledged, so silent drift in a load-bearing tool is noticeable.2026-08-31
beads-humanThe queue of things that need a person — escalation as a durable, answerable, countable bead rather than a question lost with the session.2026-08-31
beads-auditAppend-only interaction log for auditing and SFT/RL dataset generation — compounding aimed at weights, unique here.2026-08-31
beads-mailDelegates to the orchestrator’s mail provider; a store declining to grow into a runtime, in one command.2026-08-31
beads-rulesMechanically audits .claude/rules/ for contradictions and merges near-duplicates — the guide layer maintained by metric, not by LLM.2026-08-31
beads-githubTwo-way GitHub Issues bridge; GitHub also appears as a gate source and as the repo host.2026-08-31
beads-gitlabTwo-way GitLab bridge, identical shape — the uniformity is the point.2026-08-31
beads-jiraTwo-way Jira bridge; the one that most tests the “adoption bridges, not a second product surface” rule.2026-08-31
beads-linearTwo-way Linear bridge; the closest external model to beads’ own.2026-08-31
beads-adoTwo-way Azure DevOps bridge — an adoption signal for enterprise ground.2026-08-31
beads-notionNotion bridge, the only one that can init its own schema; a Notion board is a work store missing exactly this layer’s four features.2026-08-31

| pstack-poteto-mode | pstack command — The sticky-mode router: matches the task to one of 23 playbooks, copies its steps in verbatim, indexes 23 principles inline, and routes to every other skill. Every leaf is disable-model-invocation: true. | 2026-09-11 | | pstack-poteto-agent | pstack sub-agent — The style-preserving delegate; reads the mode skill in full first because a generic subagent drops the principles and drifts. | 2026-09-11 | | pstack-comment-sicko | pstack sub-agent — A deranged read-only comment reviewer; flags a comment on our own code as MUST KILL on the guilty symbol, turning prose into a reshape task. | 2026-09-11 | | pstack-how | pstack skill — How does X work; scale-adaptive parallel explorers then one synthesizing explainer, with a model-role split across the two. | 2026-09-11 | | pstack-why | pstack skill — Why it is shaped this way; run-time MCP discovery fans one investigator across seven organizational evidence categories, with an explicit epistemics contract. | 2026-09-11 | | pstack-teach | pstack skill — Explain so a person understands; built up diagram by diagram, each redrawing the last and adding one part. No pedagogy theater. | 2026-09-11 | | pstack-recall | pstack skill — Rebuild working context from two records — your own chats and the shared organizational record — into a strict capsule/threads/problems/next-move brief. | 2026-09-11 | | pstack-blast-radius | pstack skill — What a small change breaks elsewhere. Refuses to hand back the writeup; find the one fact it is safe because of and prove it on a five-rung ladder. | 2026-09-11 | | pstack-architect | pstack skill — Types, signatures, and module boundaries before code. Arena-driven sketch, Ousterhout red-flag screen, and an explicit scrap phase with falsifiable triggers. | 2026-09-11 | | pstack-arena | pstack skill — N attempts at one artifact, cross-judged from a different model family, then graft the losers into the base. Mints pattern-candidate-grafting. | 2026-09-11 | | pstack-swarm | pstack skill — N parallel cloud-default workers across slices or races; selection rule declared before spawning, and no raw worker dumps in the report. | 2026-09-11 | | pstack-interrogate | pstack skill — One reviewer per model, identical prompt and rubric. “The adversarial signal comes from model diversity, not assigned personas.” | 2026-09-11 | | pstack-no-comments | pstack skill — Acts on Comment Sicko’s findings: smallest root-cause fix in scope, plus an encoding offer (type, runtime, test, CI lint) for any claimed constraint. | 2026-09-11 | | pstack-reflect | pstack skill — Three parallel review lenses over the transcript → Accepted/Rejected/Backlog → concrete skill edits, gated by a structural-enforcement check that demotes anything a lint would do better. | 2026-09-11 | | pstack-figure-it-out | pstack skill — Design a bespoke auditable playbook when none fits. Falsifiable done predicate, rigor biased high and sized to blast radius, harness before work, INCONCLUSIVE is not a pass. | 2026-09-11 | | pstack-show-me-your-work | pstack skill — The append-only TSV decision trail → artifact-decision-log. Local by default, committed only when a reviewer needs it to trust the result. | 2026-09-11 | | pstack-tdd | pstack skill — Failing test first where the path is cheap — and the cluster member that documents when to skip. “Prefer no new test over a bad test.” | 2026-09-11 | | pstack-create-verification-skill | pstack skill — Generates a project-local harness that drives the real app for any language or platform; interviews the repo, not the user. | 2026-09-11 | | pstack-maintain-verification-skill | pstack skill — The upkeep loop: source wave plus one live pass, at most one PR of proven corrections, forcing the doc-drift vs product-regression fork. | 2026-09-11 | | pstack-unslop | pstack skill — Cut AI tells. “Must always apply.” Rule numbers are a stable API sibling skills cite by number. | 2026-09-11 | | pstack-technical-writing | pstack skill — Diátaxis + Google developer style + STE + Global English, layered — with an escape clause when a rule makes the sentence worse. | 2026-09-11 | | pstack-bro | pstack skill — Restate the last message in plain human language. The smallest skill in the plugin. | 2026-09-11 | | pstack-typescript-best-practices | pstack skill — The only paths:-attached skill; grounds type-system discipline in TypeScript syntax (constructive modeling, narrowing hierarchy, schemas before guards). | 2026-09-11 | | pstack-automate-me | pstack skill — Mines your transcripts into your own -mode skill — the framework’s offer to be replaced as the entry point, keeping pstack as the base. | 2026-09-11 | | pstack-setup-pstack | pstack command — Maps each role to a model and writes an always-applied rule; panel list length sets subagent count. Overwrites whole so re-runs stay idempotent. | 2026-09-26 | | pstack-make-bot-ui | pstack skill — A page whose buttons wake a bot over a webhook, with the sender key kept server-side and the POST body treated as untrusted. | 2026-09-11 | | pstack-benny-setup | pstack skill — Installs the dormant benny automation pack into a repository; preserves destination-only files and keeps user config outside the pack. | 2026-09-11 | | pstack-benny-triage | pstack skill — Unattended Slack issue-report triage: one thread verdict, cause-aware routing, tracker dedupe, fail-closed ticketing. | 2026-09-26 | | pstack-benny-reproduce-and-fix | pstack skill — Unattended repro through the real UI, then a bounded draft PR only after before-and-after proof. High autonomy, deliberately low authority. | 2026-09-26 | | pstack-principle-laziness-protocol | pstack principle skill — Bias to deletion and the smallest change that solves the problem. | 2026-09-11 | | pstack-principle-foundational-thinking | pstack principle skill — Get the data structures right so downstream code becomes obvious. | 2026-09-11 | | pstack-principle-redesign-from-first-principles | pstack principle skill — Redesign as if the requirement had been foundational, not bolted on. | 2026-09-11 | | pstack-principle-attack-the-premise | pstack principle skill — When two fixes sharing a premise fail the same gate, question the premise. | 2026-09-11 | | pstack-principle-subtract-before-you-add | pstack principle skill — Remove dead weight first, then build on the simpler base. | 2026-09-11 | | pstack-principle-minimize-reader-load | pstack principle skill — Count layers and hidden state; collapse one-caller wrappers. | 2026-09-11 | | pstack-principle-outcome-oriented-execution | pstack principle skill — Converge on the target architecture, no throwaway compatibility states. | 2026-09-11 | | pstack-principle-experience-first | pstack principle skill — User delight over implementation convenience; fewer polished features. | 2026-09-11 | | pstack-principle-exhaust-the-design-space | pstack principle skill — 2-3 competing prototypes compared side by side before committing. | 2026-09-11 | | pstack-principle-build-the-lever | pstack principle skill — Build the tool that does or proves it — the artifact a reviewer can rerun. | 2026-09-11 | | pstack-principle-model-the-domain | pstack principle skill — Encode the domain in a structure, not scattered conditionals. | 2026-09-11 | | pstack-principle-boundary-discipline | pstack principle skill — Guards at system boundaries; pure business logic inside. | 2026-09-11 | | pstack-principle-type-system-discipline | pstack principle skill — Make illegal states unrepresentable; parse external data at boundaries. | 2026-09-11 | | pstack-principle-make-operations-idempotent | pstack principle skill — Converge to the same end state regardless of partial prior runs. | 2026-09-11 | | pstack-principle-migrate-callers-then-delete-legacy-apis | pstack principle skill — Migrate callers and delete the old API in one wave. | 2026-09-11 | | pstack-principle-separate-before-serializing-shared-state | pstack principle skill — Eliminate the sharing before serializing it. | 2026-09-11 | | pstack-principle-prove-it-works | pstack principle skill — Verify against the real artifact, not a proxy or “it compiles”. | 2026-09-11 | | pstack-principle-fix-root-causes | pstack principle skill — Trace each symptom to its root cause and fix it there. | 2026-09-11 | | pstack-principle-sequence-verifiable-units | pstack principle skill — Units that each end in a check, ordered so the sequence proves itself. | 2026-09-11 | | pstack-principle-test-behavior-not-implementation | pstack principle skill — If it passes when every import returns undefined, rewrite or delete it. | 2026-09-11 | | pstack-principle-guard-the-context-window | pstack principle skill — Route bulk to subagents, keep summaries in the main thread. | 2026-09-11 | | pstack-principle-never-block-on-the-human | pstack principle skill — Proceed on reversible work; pause only for irreversible writes. | 2026-09-26 | | pstack-principle-encode-lessons-in-structure | pstack principle skill — Encode the rule as a lint, flag, check, or script instead of more text. | 2026-09-11 | | tessl-install | Tessl command — The package manager proper: install, uninstall, list, outdated, update — from the registry, a path, a GitHub repo, or a specific commit; per-repo or global. The framework coming apart into independently pinnable parts, expressed as a CLI. | 2026-09-12 | | tessl-search | Tessl command — Search the public and private index as one surface; results carry review scores and security findings, which is what separates a registry from a list of links. | 2026-09-12 | | tessl-init | Tessl command — Initialize a repo and auto-configure every detected coding agent (7 of them) via an MCP entry plus rules files; tessl project anchors results to the repository. | 2026-09-12 | | tessl-skill | Tessl command — Scaffold, import, lint, publish, unpublish a single skill. skill import promotes a loose SKILL.md into a bundle — the prerequisite for evaluating it at all. | 2026-09-12 | | tessl-plugin | Tessl command — The full lifecycle of the layer’s unit of trade → artifact-capability-bundle: skills, rules, MCP servers, and hooks, versioned as one. Already carries a deprecated manifest format. | 2026-09-12 | | tessl-review | Tessl command — Score a skill on validation, description, and content; automatic on publish, forkable rubric, --threshold fails the build. Is it well written? | 2026-09-12 | | tessl-review-security | Tessl command — Snyk-powered scan for prompt injection, secrets, suspicious URLs, and hidden or obfuscated text. Anchors pattern-supply-chain-scanning; warns at install, policy blocks. | 2026-09-12 | | tessl-review-fix | Tessl command — Iteratively rewrite a skill until it clears a score threshold — an autonomous loop whose target is a capability. Optimizes the rubric, not the effect. | 2026-09-12 | | tessl-scenario | Tessl command — Generate the graded tasks from a plugin, two commits, or real PRs → artifact-eval-suite; server-side feasibility check keeps filler out of the suite. | 2026-09-12 | | tessl-eval | Tessl command — Run the agent with and without the context and score the difference. Does it work? Can measure activation alone — separating did not help from never loaded. | 2026-09-12 | | tessl-workspace | Tessl command — Workspaces, orgs, roles, API keys: RBAC, install and publish policies, required skills, audit trail. Where the layer’s governance actually blocks. | 2026-09-12 | | tessl-inventory | Tessl command — Scan a source-control org and index every skill across every repo. “Govern what you can see.” The org-scale answer to sprawl the process layer creates and never manages. | 2026-09-12 | | tessl-environment | Tessl command — Named workspace-scoped secrets and MCP wiring, kept outside the shareable bundle. Replace-not-merge update semantics. | 2026-09-12 | | tessl-mcp | Tessl command — mcp start is how all seven harnesses reach the registry; mcp proxy is the workspace MCP gateway. MCP as the portability substrate rather than a per-harness feature. | 2026-09-12 | | tessl-code-review | Tessl command — Agentic PR review with versioned, pinnable lenses — the persona panel rebuilt as installable units. Implements stage-review. | 2026-09-12 | | tessl-change-risk | Tessl command — Assess a diff and exit non-zero only when human review is required; reviewer attention allocated by blast radius. Implements stage-review. | 2026-09-12 | | tessl-change-verify | Tessl command — LLM-judge verifiers over changed files — cached, sampled, dry-runnable, and capped by a call ceiling that refuses broad runs. A deterministic gate whose judge costs money. Implements stage-review. | 2026-09-12 | | tessl-launch | Tessl command — Run a capability rather than distribute it: launch an agent, or run an installed skill locally or in the cloud. Runtime-adjacent; typed input/output schemas make a skill a function call. | 2026-09-12 | | tessl-schedule | Tessl command — Run a registry plugin against a repo on a cron, with pause/resume/history. The second runtime-adjacent surface, and the one to watch for the layer’s boundary. | 2026-09-12 | | tessl-agent | Tessl sub-agent — The conversational platform agent: mines PRs and session logs for recurring agent mistakes, fixes the skill, proves it with an eval. Compounding aimed at the toolchain. | 2026-09-12 | | tessl-observability | Tessl command — Where skills actually activate across real sessions, not where they are installed. The wiki’s first measurement of agent behavior in production. | 2026-09-12 | | builder-factory | Builder skill — Factory router: configure sources, ten independent action policies, prompt overlays, schedules, and worktrees; create host automations and read them back (off-stage). | 2026-09-26 | | builder-factory-collect | Builder skill — Factory intake: collect and triage feedback, telemetry, errors, and issues with coverage accounting; one targeted follow-up question, re-triage on answer (align, intake). | 2026-09-26 | | builder-factory-lookback | Builder skill — Factory retrospective over production signal: recurrence after claimed fixes, one systemic correction at the shared boundary (learn, third flavor). | 2026-09-26 | | builder-factory-human-digest | Builder skill — read-only decision queue of everything held for human judgment, grouped by underlying pattern; never acts (off-stage). | 2026-09-26 | | builder-factory-review-prs | Builder skill — scheduled sweep of a filtered PR queue; findings kept apart from reply, approve, and merge gates; code-review cluster (review). | 2026-09-26 | | builder-factory-babysit-pr | Builder skill — follow one explicitly authorized PR through checks and review under six separate gates including a head-bound soak (release). | 2026-09-26 | | builder-factory-ship | Builder skill — verify, publish, head-guarded merge, then deployment verified separately (“a merge is not live proof”); finalize cluster (release). | 2026-09-26 | | builder-factory-watchdog | Builder skill — find stalled authorized delivery work; notify only on a verified next step, else DONT_NOTIFY (off-stage). | 2026-09-26 | | builder-factory-recover | Builder skill — resume interrupted runs only while authorization and worktree remain valid; never repeat a completed write (off-stage). | 2026-09-26 | | builder-agent-watchdog | Builder skill — audit another agent’s run as a second investigator: independent investigation, diff the two, relay sparingly (review). | 2026-09-26 | | builder-plan-arbiter | Builder skill — arbitrate competing agent plans: Adopt / Hybrid / Revise first, with borrowed pieces, rejected ideas, and an executor recommendation (plan). | 2026-09-26 | | builder-plow-ahead | Builder skill — explicit autonomy contract with listed stop conditions and an auditable decision recap; ↔ pstack never-block-on-the-human (off-stage). | 2026-09-26 | | builder-efficient-fable | Builder skill — Claude Fable as orchestrator and final judge, with cheaper subagents for heavy lifting; anchors pattern-model-tiering (off-stage). | 2026-09-26 | | builder-efficient-frontier | Builder skill — the same tiered orchestration for any high-cost frontier model (off-stage). | 2026-09-26 | | builder-stay-within-limits | Builder skill — check 5-hour and weekly usage between waves, pause at 95%, resume from a self-contained wake prompt (off-stage). | 2026-09-26 | | builder-quick-recap | Builder skill — 🟢/🟡/🔴 end-of-response status line, installed as a managed AGENTS.md / CLAUDE.md block (off-stage). | 2026-09-26 | | builder-read-the-damn-docs | Builder skill — docs-first trigger list: web-search official docs before coding against external contracts; ↔ addy-source-driven-development (implement). | 2026-09-26 | | builder-rewind | Builder skill — local-first retrieval of recent screen context from Clips Rewind, with permission-gated setup (off-stage). | 2026-09-26 | | builder-an | Builder skill + command — open and operate a granted Agent-Native app via Dispatch MCP; one read, smallest edit, readback (off-stage). | 2026-09-26 | | builder-webmcp | Builder skill — open a URL in the host’s built-in browser and use the page’s WebMCP tools before any UI automation (off-stage). | 2026-09-26 | | builder-visual-plan | Builder skill — plans as interactive, commentable MDX review surfaces; transferable plan-discipline rules (plan). | 2026-09-26 | | builder-visual-recap | Builder skill — a diff as an interactive visual recap for reviewers; optional per-PR GitHub Action (review). | 2026-09-26 | | builder-visual-edit | Builder skill — edit a running local app from route-backed screens on a hosted design canvas (implement). | 2026-09-26 | | builder-turn-into-app | Builder skill — package a proven thread or skill into a runnable Agent-Native app; ↔ gstack-skillify / pstack-automate-me with an app as the output (learn). | 2026-09-26 |

sdlc-stage

Canonical lifecycle stages — derived projections synthesized from implements: backlinks.

ArticleSummaryUpdated
stage-alignAlign on what to build before implementation (GSD Discuss / MP grilling + to-questionnaire / Addy interview-me / OpenSpec explore / SpecKit clarify / BMAD Analysis / CE brainstorm / gstack office-hours / Superpowers brainstorming / Agent OS plan-product). Ten frameworks; grilling + codebase-investigation + ideation + pressure-testing + product-direction flavors; stage-govern parked (Agent OS sharpens the advisory-vs-gated line). pstack adds the codebase-investigation flavor at scale (how/why, seven organizational evidence sources) plus an unattended intake case (benny triage).2026-10-11
stage-specifyAuthor the durable spec before code (MP to-spec + Addy spec-driven + OpenSpec propose + SpecKit specify + BMAD PRD + gstack spec + BM PRD-Creator + nano-spec create + Agent OS shape-spec). Now nine-framework; SpecKit adds a checklist gate, gstack a cross-model gate, BM a non-technical-builder HTML PRD, nano-spec the minimalist pole, Agent OS uniquely binds project standards into the spec pack.2026-08-05
stage-planResearch, design, decompose into verified units (GSD Plan / MP issues / Addy planning / SpecKit plan+tasks+analyze / BMAD Solutioning / CE plan+doc-review / gstack plan-review panel / Superpowers writing-plans; OpenSpec folds it into propose). Decompose cluster now six-framework; plan-verification five-framework; design candidate still parked. pstack is the first framework here to argue against the stage — “the best spec is code” — contributing only an escape-hatch playbook designer and a design sketch written in code shapes.2026-09-26
stage-implementWrite the code that satisfies the plan (GSD Execute / MP implement + implement-spec / Addy Build / OpenSpec apply / SpecKit implement / BMAD dev-story / CE work / gstack build / Superpowers subagent-driven+executing-plans). Execute-cluster eight-framework; debugging + TDD + worktree-isolation + interface-design clusters; Superpowers adds the densest implement roster (SDD/TDD/debug/worktrees/parallel-agents). pstack adds no execution engine, only the disciplines that run inside its playbooks (tdd, recall, a path-attached TS standard, and benny’s unattended repro-and-draft-PR loop).2026-10-11
stage-validateConfirm the build works — functional only (UAT, runtime/browser tests, spec-conformance): GSD Verify / Addy browser-testing / OpenSpec verify / SpecKit converge / CE test+dogfood / gstack Test (QA/iOS) / Superpowers verification-before-completion (a distinct claim-verification lens, pattern-evidence-before-claims). Superpowers is now the 3rd framework cleanly separating validate from review. pstack generates the harness rather than shipping one (create-/maintain-verification-skill), the first here to cover CLI, TUI, desktop, API, mobile, and library surfaces as well as the browser.2026-09-11
stage-reviewConfirm the build is good — the quality gate (code review, security, performance, simplification, architecture, design/DX audit): MP audit / Addy Review + /ship personas / BMAD code-review / CE simplify+review+optimize / gstack review+codex+cso+design/devex / Superpowers requesting+receiving-code-review. Code-review cluster now six-framework; Superpowers alone pages the review-reception side and is the 3rd framework with the clean Verify∥Review partition. pstack adds the densest review roster relative to size and the only one built on model diversity rather than personas (interrogate, blast-radius, no-comments, Comment Sicko).2026-09-26
stage-releaseFinalize & deliver the iteration (GSD Ship / Addy Ship / OpenSpec sync+archive / CE commit-push-pr+promote / gstack ship+land-and-deploy+canary / Superpowers finishing-a-development-branch / MP pr, body only). Finalize cluster now five-framework; two flavors: ship-to-prod vs spec-maintenance. Superpowers offers a merge/PR/keep/discard decision menu and (like GSD/OpenSpec) stops at PR/merge — no deploy. stage-operate candidate still capability-level only.2026-10-11
stage-learnThe 7th stage. Harvest reusable learnings from completed work and fold them into a durable form future iterations read as grounding — the loop-closing arrow. Now also Matt Pocock (mp-retro, v1.3.0: an environment-compounding flavor, lessons → checks/standards/pointers). Four frameworks: agent-grounding corpus (CE / gstack) vs team retrospective (BMAD / gstack) vs capability-compounding (gstack-skillify / Superpowers writing-skills). Plausibly the first genuinely new SDLC stage the agent era adds. pstack populates all three flavors (reflect → targeted skill edits gated by a lint-rule test, automate-me → a personal mode skill, teach → a human explainer).2026-10-11

artifact

Concrete outputs capabilities produce (commits, specs, plans, …). See the visual artifact index — a whole-lifecycle flow overview plus one per-stage diagram showing how these artifacts relate and lead into one another.

ArticleSummaryUpdated
artifact-phase-contextGSD {phase}-CONTEXT.md — locked decisions + scope (MP’s clashing CONTEXT.md renamed to GLOSSARY.md in v1.3.0).2026-10-11
artifact-plan-md{phase}-PLAN.md — executable task prompts (GSD); also Addy tasks/plan.md+todo.md; OpenSpec/SpecKit tasks.md; CE guardrail plans; BM milestones/N/prompt.md build prompts; nano-spec todo.md; Superpowers bite-sized docs/superpowers/plans/… from sp-writing-plans.2026-09-26
artifact-plan-recordSeeds plans.jsonl row — a plan as schema-validated data rather than prose: template-shaped sections, steps that spawn one child seed each with their dependency edges wired, a derived status, and a children array a runtime executes in order. The direct contrast to artifact-plan-md.2026-08-31
artifact-research-mdRESEARCH.md — domain/tech research output (GSD parallel researchers; SpecKit research.md; BMAD Analysis-phase research; MP mp-research background primary-source agent).2026-07-09
artifact-uat-md{phase}-UAT.md — UAT results + diagnosed gaps.2026-06-27
artifact-atomic-commitOne atomic git commit per completed task/slice/story (GSD + Addy + BMAD + CE + gstack + Superpowers).2026-07-17
artifact-pull-requestPR opened at ship time with auto summary (GSD + Addy + CE + gstack + Superpowers).2026-09-26
artifact-prdProduct Requirements Document — the durable requirements spec (BMAD bmad-prd + BM Skills bm-prd-creator; MP’s former to-prd now produces a spec → artifact-spec-md).2026-07-09
artifact-issueTracker issue from a plan/spec — MP to-tickets (tracer-bullet + blocking edges), wayfinder (decision tickets), triage (agent-ready briefs); SpecKit exports tasks.md; gstack-spec files a deduped issue.2026-10-11
artifact-adrArchitecture Decision Record — MP (during grilling), Addy (at decision/ship time), and nano-spec (doc.md Key Decisions).2026-07-13
artifact-domain-modelMP GLOSSARY.md (was CONTEXT.md until v1.3.0) — shared-language glossary (clash with GSD phase-context resolved by the rename).2026-10-11
artifact-handoff-docCompacted handoff document for agent/session transitions (MP).2026-09-26
artifact-spec-mdThe spec document written before code — Addy SPEC.md + SpecKit spec.md + BMAD SPEC kernel + gstack five-phase spec (Codex-gated) + MP to-spec (v1.1, seams-first); counterpart to artifact-prd.2026-07-09
artifact-review-reportCode review report — Addy five-axis + BMAD adversarial + CE persona + gstack (review/codex/design/devex) + MP two-axis (Standards∥Spec) + Superpowers (sp-requesting-code-review severity-labelled) findings.2026-09-26
artifact-security-auditOWASP threat/vulnerability audit report (Addy + CE + gstack; gstack-cso adds STRIDE + exploit scenarios).2026-07-05
artifact-perf-auditCore Web Vitals scorecard; metric-honesty rule (Addy + CE + gstack; gstack-benchmark adds before/after-per-PR regression).2026-07-05
artifact-changelogChangelog + semantic-version tag (Addy + gstack; gstack-ship bumps VERSION + CHANGELOG).2026-07-05
artifact-launch-checklistPre-launch checklist + rollback plan; the /ship go/no-go (Addy).2026-07-04
artifact-spec-deltaOpenSpec’s signature — ADDED/MODIFIED/REMOVED requirement deltas (+ Given/When/Then scenarios) against a living spec; merged on archive.2026-07-04
artifact-proposal-mdOpenSpec proposal.md — the why/what + scope of a change; rationale layer, narrower than a full PRD/SPEC.md.2026-07-04
artifact-design-mdDesign/technical-approach doc — OpenSpec design.md; SpecKit plan.md+data-model.md+contracts/; BMAD UX DESIGN.md+EXPERIENCE.md; gstack + BM design systems (design-consultation / bm-design-system code scaffold); Superpowers docs/superpowers/specs/…-design.md from sp-brainstorming.2026-07-17
artifact-constitutionSpecKit’s signature — .specify/memory/constitution.md; immutable project-wide governing principles (numbered articles) that gate every downstream plan/analysis.2026-07-04
artifact-checklistSpecKit quality checklist validating requirements completeness/clarity/consistency (“unit tests for your English”); a spec-quality gate.2026-07-04
artifact-storyBMAD’s signature — a context-rich story-[slug].md (AC + tasks + Dev Notes + Dev Agent Record) that embeds all implementation context; the atomic unit of work. Richer counterpart to artifact-issue.2026-07-04
artifact-architectureBMAD ARCHITECTURE-SPINE.md — a lean invariants-only system-architecture contract; structure is “seed”, owned by code once it exists. Above artifact-design-md.2026-07-04
artifact-product-briefPre-PRD align-stage scoping doc — BMAD brief.md (+ PRFAQ + forged-idea) + gstack office-hours reframed design doc; akin to OpenSpec’s proposal.md.2026-07-05
artifact-solution-docCE’s signature — schema-validated docs/solutions/ learning file; machine-consumable grounding future agents auto-read (CE + gstack-learn). The agent-facing output of stage-learn; counterpart to artifact-retrospective.2026-07-05
artifact-brainstorm-mdCE docs/brainstorms/ requirements-only unified plan (WHAT, no HOW); lighter/earlier than a PRD, feeds ce-plan.2026-07-04
artifact-strategy-mdCE STRATEGY.md upstream product-strategy anchor read by ideate/brainstorm/plan; structural analogue of SpecKit’s constitution (different scope).2026-07-04
artifact-explainerCE dense visual explainer of a concept/diff/recent work (ce-explain); the human-facing learning sibling of artifact-solution-doc. pstack produces one at three depths (how / why / teach), the last built up diagram by diagram.2026-09-26
artifact-design-mockupgstack AI-generated visual mockup variants on a comparison board with taste memory (gstack-design-shotgun); disposable design exploration, distinct from the design system (design-md) and the production HTML.2026-07-05
artifact-diataxis-docsgstack Diataxis-structured documentation (tutorial/how-to/reference/explanation) generated to match the code with a coverage map (gstack-document-generate / -release). pstack stacks Diátaxis with Google developer style, STE, and Global English (pstack-technical-writing).2026-09-11
artifact-retrospectiveThe retrospective report — team-process flavor of stage-learn (gstack-retro weekly + BMAD bmad-retrospective post-epic); the human-facing sibling of artifact-solution-doc.2026-09-26
artifact-nano-spec-packnano-spec’s signature — a per-task folder of exactly 4 tiny markdown files (README=context/scope · todo=plan+acceptance · doc=decisions/schema · log=dated journey); the minimalist alternative to a single-doc spec/PRD/delta.2026-07-13
artifact-skill-docA reusable skill definition (SKILL.md + supporting files) — executable process knowledge that auto-triggers and is followed as a procedure. Superpowers’ sp-writing-skills (TDD-for-docs) + gstack’s gstack-skillify; the capability-compounding output of stage-learn. pstack adds three producers — a generated per-repo verification skill, a personal -mode skill mined from transcripts, and targeted edits to existing skills.2026-09-11
artifact-standardsAgent OS’s signature — a project-local corpus of declarative coding conventions (agent-os/standards/ + an index.yml matcher), token-frugal and injected on demand; the guide (feedforward) layer of topic-harness-engineering. The advisory, mined-from-code counterpart to SpecKit’s gated constitution. pstack adds a path-attached TypeScript standard and an always-applied model-role rule; its pstack-unslop gives prose rules stable ids sibling skills cite by number.2026-09-11
artifact-product-docsAgent OS agent-os/product/ trio — mission.md + roadmap.md + tech-stack.md; a lightweight standing product-direction anchor (from agent-os-plan-product); counterpart to CE’s STRATEGY.md.2026-08-05

| artifact-decision-log | pstack’s append-only TSV decision trail (ts/phase/decision/why/evidence/result), one row per fork, revert, or checkpoint. The only durable artifact here whose reader is a human who was not watching rather than the next agent — evidence is a pointer, never prose, and history is never edited. Local by default; committed when a reviewer needs the trail to trust the result. | 2026-09-26 | | artifact-capability-bundle | The supply layer’s unit of trade — a versioned package of skills, rules, MCP servers, and hooks, installed and updated as one “much like a package in npm or pip” (tessl-plugin). Through hooks and MCP it extends the harness’s own primitives, not just the prompt — the precise point where the registry layer reaches down into the harness layer. | 2026-09-12 | | artifact-eval-suite | A directory of scenarios that grade a capability, each pairing a task with a weighted rubric, versioned alongside the capability it grades (tessl-scenario). A regression suite for prose: the mechanism that makes a shared skill corpus safe to edit, and the durable half of the config-eval instrument topic-ai-native-sdlc recorded as unshipped. | 2026-09-12 | | artifact-autonomy-policy | Per-project document of which external actions an agent may take unattended and under what conditions (never / manual / criteria / proof point, per action); the Factory’s .agent-factory/config.yaml. Governs authority, not design or style. | 2026-09-26 |

pattern

Reusable techniques capabilities apply (wave parallelism, plan-then-act, …).

ArticleSummaryUpdated
pattern-spec-driven-developmentDrive agents from explicit versioned specs, not freeform prompts. Shared: GSD + MP + Addy + OpenSpec + SpecKit + BMAD + gstack + BM + nano-spec + Agent OS (SpecKit is the reference implementation; nano-spec + Agent OS the minimalist/shape-not-generate instances).2026-08-05
pattern-living-specificationKeep a permanent spec as source of truth; express each change as a merged delta (OpenSpec’s signature).2026-07-04
pattern-project-constitutionExternalize immutable project-wide principles into one governing document and gate every downstream artifact against it (SpecKit’s signature). pstack’s 23 principle skills are the navigable-corpus alternative to one immutable document, bound by a citation requirement rather than a gate.2026-09-11
pattern-fresh-context-subagentsClean-context subagents per task to beat context rot. Shared: GSD + Addy + BMAD + CE + gstack + Superpowers (Superpowers: fresh subagent per task/review/problem, briefs as files).2026-09-26
pattern-wave-parallelismGroup independent tasks into dependency-ordered parallel waves (GSD); Superpowers’ sp-dispatching-parallel-agents is the concurrent-dispatch variant without dependency ordering; infra-side: sandcastle (parallel runs / session fork).2026-09-26
pattern-plan-verification-loopGate plans through a multi-dimension checker (or persona panel) before execution. Shared: GSD + SpecKit + BMAD + CE + gstack (now five-framework).2026-07-05
pattern-grillingInterrogate the human until decisions resolve. Shared: GSD + MP + Addy + SpecKit + BMAD + CE + gstack + Superpowers + Agent OS (Agent OS makes AskUserQuestion interviews its only interaction mode).2026-08-05
pattern-test-driven-developmentRed-green-refactor; test-first feedback. Shared: GSD + MP + Addy + SpecKit + BMAD + gstack + Superpowers (non-negotiable in SpecKit via constitution; Superpowers via delete-and-restart rhetoric, even applied to skill authoring). pstack is the cluster member that argues for its own limits and supplies its falsifiable quality check (would it pass if every import returned undefined?).2026-09-11
pattern-vertical-sliceTop-to-bottom independently-shippable work units. Shared: GSD + MP + Addy + BMAD + CE + Superpowers (Superpowers: each plan task is the smallest unit carrying its own test cycle).2026-07-17
pattern-systematic-debuggingReproduce→minimize→hypothesize→instrument→fix. Shared: GSD + MP + Addy + CE + gstack + Superpowers (gstack + Superpowers share an Iron-Law “no fix without investigation” + stop-after-3).2026-09-26
pattern-session-handoffCompact context across session/agent boundaries. Shared: GSD + MP + gstack + nano-spec (gstack adds WIP-checkpoint commits; nano-spec’s always-current 4-file pack is itself the handoff); infra-side: sandcastle (session resume) + warren (mulch/steer). pstack is the first to page the suspension half (a Pause safely playbook complementing Session pickup) and to reconstruct from two records rather than one (pstack-recall).2026-09-26
pattern-deep-modulesOusterhout — rich functionality behind a simple interface (MP + Addy). pstack imports Ousterhout’s red-flag vocabulary directly as a pre-synthesis screen in pstack-architect.2026-09-11
pattern-throwaway-prototypeBuild to learn, then discard. Shared: MP + gstack (gstack-design-shotgun mockup variants). Now has a non-discarding variant: pattern-candidate-grafting.2026-09-26
pattern-anti-rationalizationExcuse/rebuttal tables + Red Flags in every skill; co-signature of Addy + Superpowers (Superpowers escalates to Iron Laws + a skill-discovery bootstrap).2026-07-17
pattern-evidence-before-claimsVerify, then assert: run the command and read the output before any “done/fixed/passing” claim. Superpowers’ signature (sp-verification-before-completion Iron Law); the honesty gate adjacent to anti-rationalization. pstack grades evidence rather than merely requiring it — pstack-blast-radius’s five-rung ladder, and INCONCLUSIVE is not a pass.2026-09-26
pattern-adversarial-review”The reviewer must find issues” — doubt loop / hunter layers / idea pressure-test / Codex challenge / dispatched two-stage review. Shared: Addy + BMAD + CE + gstack + Superpowers.2026-09-26
pattern-source-groundingCite official docs; research before building; flag the unverified. Shared: Addy + CE + gstack (gstack’s “Search Before Building” ethos).2026-09-26
pattern-context-engineeringCurate the right context at the right time; engineer it into the work unit. Shared: Addy + BMAD + gstack + Agent OS (Agent OS is built around this — inject-standards + the index.yml matcher); harness-side: CLAUDE.md/AGENTS.md + MCP.2026-09-26
pattern-contract-firstDesign the interface before the implementation; Hyrum’s Law. Shared: Addy + SpecKit (SpecKit’s contracts/).2026-09-26
pattern-measure-firstProfile before optimizing; metric-honesty rule. Shared: Addy + CE + gstack (gstack-benchmark baselines before/after).2026-07-05
pattern-trunk-based-developmentShort-lived branches, atomic commits, always-releasable trunk. Shared: Addy + CE + gstack + Superpowers (Superpowers: short branch → merge/PR decision menu with worktree cleanup).2026-07-17
pattern-shift-leftMove quality gates earlier; faster is safer (Addy).2026-07-04
pattern-feature-flagsDecouple deploy from release; staged rollout; instant rollback (Addy).2026-07-04
pattern-parallel-persona-reviewConcurrent specialist/lens review fan-out, then merge. Shared: Addy + BMAD + CE + gstack (gstack’s plan-review panel + smart routing).2026-07-05
pattern-persona-agentsA distinct named expert persona per SDLC role + Party-Mode roundtables. Shared: BMAD (signature) + gstack (CEO/eng/designer/QA/CSO/SRE specialists). pstack uses it exactly once (pstack-comment-sicko) and argues against the mechanism everywhere else — the clearest counter-position in the wiki.2026-09-11
pattern-scale-adaptive-planningSize the ceremony to the work — Quick Flow → BMad Method → Enterprise / Levels 0-4; just-in-time design. Shared: BMAD (signature) + gstack + nano-spec + Agent OS (nano-spec + Agent OS pick a deliberately-light fixed point on the ceremony spectrum). pstack applies it to rigor rather than ceremony — evidence burden sized to blast radius (pstack-figure-it-out).2026-09-11
pattern-knowledge-compoundingEach unit of work leaves reusable, (ideally machine-consumable) lessons future work auto-reads, so the lifecycle compounds. Shared: Compound Engineering + BMAD + gstack + Superpowers + Agent OS (gstack + Superpowers add capability-compounding; Agent OS compounds standards via profile-sync). The technique behind stage-learn; CE’s signature; now also an infra-layer capability — warren’s .mulch/ bakes it into the runtime. pstack compounds from transcripts (pstack-reflect, pstack-automate-me) with an explicit brake on prose accretion.2026-09-26
pattern-autonomous-loopChain the full pipeline hands-off, self-correcting to a machine-checkable success gate. Shared: CE (/lfg, ce-dogfood) + gstack (qa, ios-fix, canary); the execution-layer home for AFK agents — sandcastle + warren. pstack decouples autonomy from authority — five long-run playbooks, and benny’s fully unattended loop still ending at a bounded draft PR.2026-09-26
pattern-worktree-isolationRun each unit of work in a dedicated git worktree so parallel/autonomous work never corrupts the trunk. Shared: CE + Superpowers (both make it a first-class skill; Superpowers adds native-tool-first + clean-baseline check); the filesystem counterpart to fresh-context subagents; infra-side now provided by sandcastle (worktree/branch) + warren (bwrap/pod). pstack states it as a principle cited at every fan-out (pstack-principle-separate-before-serializing-shared-state).2026-09-26
pattern-edit-guardrailsGate the agent’s mutations: confirm destructive commands + hard-lock edits to a directory (gstack careful/freeze/guard; investigate auto-freeze). gstack’s signature; the complement to worktree-isolation.2026-09-26
pattern-cross-model-reviewAn independent second opinion from a different model/vendor; overlap = high-confidence, unique = blind-spot catch. Shared: gstack (/codex) + Compound Engineering (ce-code-review). Agreement is signal, not a mandate. pstack is now the purest instance — multi-model by construction, with pstack-interrogate rejecting persona panels by name and pstack-setup-pstack existing solely to map roles to models.2026-09-26
pattern-deterministic-gatesGate the work on checks a program decides — lint, types, tests, build, scanners — reading an exit code rather than a model’s judgment: cheap, reproducible, un-gameable. Shared: gstack (gstack-health) + Addy (addy-ci-cd) + CE (lfg watch-CI-until-green) + Matt Pocock (mp-implement) + Superpowers (sp-verification-before-completion). The computational counterweight to the wiki’s three inferential review patterns (Fowler’s split, previously prose-only in topic-harness-engineering); infra-side provided by bernstein (named gate pipeline, required gates hard-block) + sandcastle (exec()-gating). pstack turns one on the framework itself: pstack-reflect demotes any learning a lint rule would enforce better.2026-09-26

| pattern-candidate-grafting | Run N attempts at the same artifact, pick a base, then harvest the losers for the one or two ideas worth porting in. The variant of throwaway-prototype that does not discard, and distinct from cross-model review (several models each produce a whole artifact). Rubric derived before fan-out and withheld from candidates; a cross-judge from another model family; a judge/parent disagreement read as an ambiguous rubric. pstack signature (pstack-arena, pstack-architect). | 2026-09-26 | | pattern-tooling-leverage | Build the tool that does or proves the work — codemod, script, generator, skill — instead of doing it by hand. The load-bearing clause is the second one: the tool is the artifact a reviewer can rerun, which converts an assertion into evidence. The constructive complement of pattern-evidence-before-claims. pstack signature (pstack-principle-build-the-lever, pstack-create-verification-skill, pstack-blast-radius). | 2026-09-11 | | pattern-idempotent-operations | Converge to the same end state regardless of partial prior runs. Ordinary ops engineering that acquires an edge in agent work, where runs are interrupted constantly (compaction, a killed subagent, a dropped cloud worker) — the precondition that makes pattern-autonomous-loop and pattern-session-handoff safe. Most visible as a setup command that overwrites its whole output (pstack-setup-pstack). | 2026-09-26 | | pattern-capability-evals | Prove a capability works by running the agent on real tasks twice — with and without it — and scoring the difference; keep the scenarios as a regression suite. “Proof it changes what the agent does, not just that it reads well.” The first pattern here whose subject is a capability rather than software, and the answer to the failure mode where nobody dares edit a shared skill. Supplied by tessl; pstack-poteto-mode’s blinded Eval playbook is the framework-side instinct without the measurement. | 2026-09-12 | | pattern-supply-chain-scanning | Scan a capability before install for prompt injection buried in instructions, hardcoded secrets, suspicious URLs, and hidden or obfuscated text. The wiki’s guardrail patterns bound what the agent may write (pattern-edit-guardrails) or reach; this bounds what it may read. Instructions became an attack surface the moment capabilities became things you install rather than write. Supplied by tessl (Snyk-powered, severity-graded, warns rather than blocks). | 2026-09-12 | | pattern-action-gating | Authority decomposed per external action (fix, reply, close, review, approve, publish, merge, deploy, recover, notify); no inference between them; live-state recheck and head-bound evidence before each write. builder-skills (signature), pstack benny; enabled structurally by gh-aw safe outputs. | 2026-09-26 | | pattern-model-tiering | Expensive model for judgment, cheap models for bounded heavy lifting, with re-verification at the price boundary. builder-skills, pstack, GSD; provided by Factory Droid’s complexity routing. | 2026-09-26 |

harness

The agent-program layer — the harness that loads a framework’s skills/commands and drives the model’s tool-call loop (Claude Code, pi, OpenCode, …). Neither a framework (ships no methodology) nor a runtime (doesn’t orchestrate); the pivot both other layers are defined against — frameworks runs_on: it, runtimes runs: it — connecting to the ontology through the execution primitives it enables: as patterns. See the harness layer overview + capability matrix.

ArticleSummaryUpdated
claude-codeAnthropic’s Claude Code — the official agentic coding harness and the wiki’s reference terminal harness. Ships execution primitives, not methodology: tool-call loop, first-class sub-agents (Agent/Task tool, fresh context), skills (SKILL.md + auto-trigger), MCP, hooks, permission/plan modes, CLAUDE.md/memory + compaction, plus terminal/desktop/web/IDE surfaces and the Agent SDK. Anthropic models only. The node both other layers were defined against: all 12 frameworks runs_on: it; both runtimes (sandcastle, warren) runs: it. Enables pattern-fresh-context-subagents + pattern-edit-guardrails + pattern-session-handoff + pattern-context-engineering.2026-09-26
opencodeAnomaly’s (ex-SST) opencode — open-source (MIT), model-agnostic terminal harness (Claude/GPT/Gemini/… + OpenCode Zen). Batteries-included like Claude Code — first-class sub-agents (build/plan/explore/scout), MCP, a native plugin+hook system, plan/build modes, permissions — across TUI/desktop/IDE. Officially supported by 6 frameworks; spawned by sandcastle. Enables the same four patterns as Claude Code. The open, model-agnostic pole.2026-09-26
piZechner/Earendil’s pi — open-source (MIT), minimal-core terminal harness: 4 built-in tools (read/write/edit/bash), with sub-agents, MCP, permissions, and plan mode deliberately excluded from core → TypeScript extensions. Model-agnostic, terminal-only. Named by compound-engineering + superpowers; spawned by sandcastle + warren. Enables only pattern-session-handoff + pattern-context-engineering (omits sub-agents + guardrails — the sharpest cross-harness contrast). The minimalist pole.2026-09-26
factory-droidFactory.ai’s Droid — proprietary terminal harness with a Claude-Code-shaped primitive set over the AGENTS.md standard: first-class Custom Droids (fresh context + own session + per-droid model), skills, 40+ MCP servers, hooks, plugins, and autonomy levels (off/low/medium/high). Its signatures are multi-model routing (Anthropic/OpenAI/Google/open-weight, mid-session swap, complexity-tiered, BYOK, free Droid Core) and Missions multi-agent orchestration; runs TUI, headless droid exec (CI), IDE, web. Named by compound-engineering + gstack + superpowers. Enables the same four patterns as Claude Code. The model-routing pole.2026-09-26

runtime

The execution layer — harness-agnostic substrates that decide where and how agents run (sandbox isolation, parallelism, AFK autonomy, steering, persistence), as opposed to the process layer’s what. A runtime performs no SDLC stage; it connects to the ontology through the harnesses it runs: and the patterns it enables:. See the runtime layer overview + orchestration matrix.

ArticleSummaryUpdated
runtime — indexThe layer overview plus the 11-concern orchestration profile matrix (isolation, parallelism, coordination logic, autonomy, verification, steering, persistence, …) across all five members, the pattern-supply roster, and the broader-category watchlist. The conceptual synthesis — factory anatomy, design axes, profiles, glossary — lives on topic-software-factory.2026-09-01
sandcastleMatt Pocock’s Sandcastle (@ai-hero/sandcastle, MIT) — a TypeScript library for orchestrating AI coding agents in isolated sandboxes: run() sandboxes an agent with a branch strategy (head / merge-to-head / branch) and merges the commits back. Provider-agnostic (Docker/Podman/Vercel/none; Claude Code/Codex/pi/Cursor/OpenCode/Copilot). First-class AFK (maxIterations + completionSignal + idle/completion timeouts), warm reusable sandboxes with exec-gating, session resume/fork, schema-validated structured output. The library pole of the runtime layer; enables pattern-worktree-isolation + pattern-autonomous-loop + pattern-wave-parallelism + pattern-session-handoff.2026-07-26
warrenJaymin West’s Warren (os-eco, MIT, v0.9.10) — “Coolify for coding agents”: a self-hostable control plane for ephemeral agents. Dispatch (UI/CLI/API) → sandbox (bwrap workspace or k8s pod) → steer mid-run → validate → push branch → auto-PR → reap. Harness-agnostic (claude-code/sapling/pi). Opt-in os-eco power features: .mulch/ persistent cross-run memory, .seeds/ issue queue, canopy versioned prompts, plot coordination. The platform pole; uniquely enables pattern-knowledge-compounding in the runtime, plus pattern-autonomous-loop + pattern-worktree-isolation + pattern-session-handoff.2026-07-26
bernsteinAlex Chernysh’s Bernstein (sipyourdrink-ltd/bernstein, Apache-2.0) — “Kubernetes for AI coding agents”: a deterministic orchestrator. A goal is decomposed once into a task DAG, then scheduled by pure Python with zero LLM tokens in the coordination loop, run in parallel git worktrees (or docker/e2b/modal/daytona/blaxel/runloop/vercel), and gated by a janitor (declarative completion signals + lint/type/test/PII pipeline) and a review gate that enforces a fresh session and a different model. 40+ CLI adapters. Confidence-decayed lessons, HITL-gated diary synthesis, HMAC-chained audit + signed lineage, cluster mode, air-gap. The coordination pole; the first runtime to supply pattern-evidence-before-claims + pattern-cross-model-review + pattern-fresh-context-subagents as infrastructure, plus pattern-worktree-isolation + pattern-wave-parallelism + pattern-autonomous-loop + pattern-knowledge-compounding + pattern-session-handoff.2026-08-31
sssfIndyDevDan’s Super Simple Software Factory (disler/super-simple-software-factory, MIT) — a deterministic Python control plane stamped from a Claude Code skill: “Agent proposes, code disposes.” An ADW script owns sequencing, retries, and acceptance; agents run as bounded run.phase() blocks; a typed Pydantic envelope crosses every seam (parse failure re-prompts the same session, never a restart); gates verify the envelope’s claims after the fact; writes:/protected_files breaches are rolled back by diffing the repo around each call; every event streams live into WAL SQLite read by one cursor query. Twelve starter ADWs, a five-agent roster with a different model per phase. pi only (claude_code stubbed); no sandbox, no parallelism, no PR flow, no cross-run memory — by admission. The minimal pole; the layer’s first supply of pattern-contract-first + pattern-edit-guardrails, plus pattern-deterministic-gates + pattern-evidence-before-claims + pattern-context-engineering + pattern-session-handoff + pattern-autonomous-loop.2026-08-31
gh-awGitHub’s Agentic Workflows (github/gh-aw, MIT, technical preview) — “Actions + Agent + Safety”: markdown workflows (YAML frontmatter + prose instructions) that gh aw compile turns into hardened Actions lock files (SHA pinning, actionlint/zizmor/poutine scanners). The agent job runs read-only — one of five engines: copilot (default) · claude · codex · gemini · pi — inside an optional firewall container with proxy-enforced egress; ~45 typed safe outputs (create-issue, create-pull-request, …) are applied by separate scoped-token jobs only after an isolated threat-detection verdict. Triggers are the repo’s own event stream plus cron, fuzzy schedules, /slash and label commands; autonomy is metered by max-turns, AI-credit budgets, cooldown, stop-after. cache-memory/repo-memory give integrity-scoped cross-run state; gh aw logs/audit/health/forecast/outcomes the audit surface. No server — the control plane is compiled into CI. The event-driven pole; anchors topic-software-factory’s 📡 repo-reactor profile; enables pattern-autonomous-loop + pattern-worktree-isolation + pattern-edit-guardrails (the structural shape) + pattern-deterministic-gates + pattern-knowledge-compounding.2026-09-26

store

The state layer — the durable work graph or memory corpus that outlives any single agent run. See the store index for the layer’s comparison matrix and the conventions for the schema.

ArticleSummaryUpdated
store — indexThe layer overview plus a 24-row comparison matrix: storage substrate, merge model, sync, memory surface, ephemerality, workflow templating, and where the two members disagree.2026-08-31
beadsSteve Yegge / gastownhall Beads (bd) — “distributed graph issue tracker for AI agents, powered by Dolt” (MIT, Go, ~109 commands). Its own charter names the orchestration layer and refuses to be it, scoping beads to “issue tracking primitives”. Versioned SQL storage with cell-level merge and content-hash ids; five typed dependency edges of which only some gate work; knowledge-graph links; a formula→proto→molecule workflow engine with an ephemeral phase; gates and merge slots as blocking beads (coordination as work items); a first-class memory surface (remember/kv/prime, budget-aware) and semantic compaction; federation; a human-needed queue; an audit log doubling as a fine-tuning dataset; six tracker bridges. Implements one stage (beads-mol) by design.2026-08-31
seedsJaymin West Seeds (sd) — “git-native issue tracker for AI agent workflows” (MIT, Bun/TS, 37 commands), part of the os-eco ecosystem with warren. “The JSONL file IS the database” — plain diffable files merged by git (merge=union + dedup-on-read), written specifically to replace beads and arguing against its storage design by name. The layer’s boundary-crosser: unlike beads it bakes a planning methodology into the store — sd plan, templated and AJV-gated, spawning the children — so 14 of its 37 capabilities are on-stage.2026-08-31

registry

The supply layer — the versioned index capabilities are discovered in, scanned, scored, evaluated, policy-gated, and installed from, before any run begins. Where a store holds what a run produced, a registry holds what a run is provisioned from; it is the only layer whose unit of trade is a capability rather than a session. A vendor’s own marketplace (Anthropic’s, cursor/plugins, opencode’s) is a harness feature, not a member — see the boundary test. Layer overview + queue: index.md.

ArticleSummaryUpdated
tessl”An open platform for managing agentic development across your organization.” Registry and package manager, governance (RBAC, install/publish policy, Snyk scanning), evals, observability, org inventory, and a platform agent — 101 commands across 21 pages. Founded by Snyk’s Guy Podjarny; paused its own framework product to build this, which is itself evidence for the layer. Reproduces the wiki’s stage-review ∥ stage-validate split independently, for the skill corpus (“a review tells you whether a skill is well written; an eval tells you whether it works”). Mints pattern-capability-evals, pattern-supply-chain-scanning, artifact-capability-bundle, artifact-eval-suite. Ships stage-review capabilities and a runtime-adjacent launch/schedule surface — recorded as prose, and flagged as a re-ingest trigger.2026-09-12

topic

Curated cross-cutting overlays (Maps of Content) — authored, top-down reference pages that link out to specifics across the ontology. Not ontology nodes: they store no edges and change no synthesis. See CONVENTIONS §The topic layer.

ArticleSummaryUpdated
topic-harness-engineeringSteering agents toward project conventions, and refining it over time — Martin Fowler’s Harness Engineering frame (guides/feedforward + sensors/feedback, closed by a steering loop; computational vs inferential controls; keep quality left), threaded through the wiki’s existing pages. Reconciles Fowler’s broad “harness” with this wiki’s harness node; the home for the agent-os guide layer and the “as models improve” analysis.2026-08-05
topic-agent-readinessScoring the repository (and the org) the agent has to work in — Factory’s Agent Readiness (repo-scoped, 8–9 pillars × 5 levels, 100+ binary signals, /readiness-report + /readiness-fix) and VirtusLab’s Visdom AI-Native SDLC Maturity Matrix (org-scoped, 4 perspectives × 4 capabilities × 5 levels, 240 practice guides), mapped onto the wiki’s existing pages. The inverse axis — the substrate is the dependent variable, not the process; closes topic-harness-engineering’s harnessability gap. Records six criteria families the wiki has no page for (test-suite trustworthiness, feedback latency, agent economics, AI-code provenance, auto-merge, org design) and the trigger for graduating this layer into a namespace.2026-08-07
topic-compounding-loopAssessing what past agent sessions learned, so the next one starts ahead — the harvest → externalise → re-inject → maintain circuit, with the three tiers of evidence a tool can actually read (agent transcripts · repo artefacts · persisted working context) and the four things that compound (lessons · capabilities · standards · preferences). The third of the actionable topic trio: topic-agent-readiness is the substrate, topic-harness-engineering the controls, this the loop that refines them. Records six gaps — session mining has no pattern or artifact, nothing measures whether compounding works, and learn outputs are all guides and never sensors.2026-08-28
topic-ai-native-sdlcThe organization-level transformation, from the harness vendor itself — Anthropic Applied AI’s AI-Native SDLC playbook (2026-08-21) read against the wiki: the bottleneck-moved thesis, the committed artifact chain (intent.md → spec.md → plan.md → diff → PR → incident, each acceptance triggering the next stage), six plays-stages mapped onto the wiki’s eight derived stages, and the skill-advisory / hook-deterministic two-tier control vocabulary. Records the convergence: a vendor governance document independently landing on ~10 of the wiki’s patterns, plus one instrument no community framework ships — continuous evals of the agent’s configuration (CLAUDE.md/skills/hooks changes regression-tested in CI). Stage 6’s bands.yaml tiered autonomy is topic-software-factory’s anatomy arrived at from the compliance side. Deliberately not a framework ingest — prose and templates, not an installable capability set.2026-09-01
topic-software-factoryThe general architecture of the execution layer — “software factory” generalized from sssf’s proper name into the layer’s concept: the anatomy every runtime shares (trigger → control plane → isolated worker → gates → merge, with a store beside it), four design axes (control-plane location, trigger model, isolation substrate, autonomy scope — the last two adopting the loop-engineering taxonomy’s values), and a morphological grid with four runtime-anchored profiles: 🎫 ticket runner (sssf) → 🖥️ monitored service (warren) → 🏭 fleet factory (bernstein), plus 📡 repo reactor (gh-aw) beside that path, sandcastle as the embeddable substrate beneath them. Carries the layer’s glossary — the canonical control plane definition, plus gate, envelope, ADW, loop contract, intake, budget, escalation, maker/checker — and relates the wiki’s three level-shaped frames (readiness, loop maturity, profiles) without merging them.2026-09-26