Each stack is one lane, read left to right. Point at a step or a labelled connector and its details open in the panel on the right. Click to pin them; click again to release. Esc closes the panel. The address of the page records a pinned selection, so a link to it shares it. The two icons in a step list what runs it.

Steps
PlanBuildCheckShipLearna human decides herea warning inside: do not take the step at face value
Connectors
next step, or a loop backfeeds the next piece of workour inference, not stated in the sourcemanual: nothing starts it, the operator has to aska choice made here decides a later branch
What runs a step
namecolumn heading: what runs the steps under itSkills and Files: what the model readsTools and Hooks: code that ships with the stack

Jesse Vincent · Claude Code, about 15 other harnesses

15 skills, no commands. A session-start hook injects a rule that skill use is mandatory. The human gates the design, the plan and the merge; in between the agent runs without pausing and records each decision it made alone.
Order, per the authorrecommended in docs and skill hand-offs; nothing checks the order
README, "The Basic Workflow": /brainstorming, /using-git-worktrees, /writing-plans, /subagent-driven-development or /executing-plans, /test-driven-development, /requesting-code-review, /finishing-a-development-branch. Each skill names the next one in its own text. The skills differ from the README: the worktree is created after the plan, per-task review uses its own prompt, and whole-branch review is not in the README list.
brainstormingskill
writing-plansskill
subagent-driven-development or executing-plansone of two skills; the human picks at the plan hand-off
finishing-a-development-branchskill

poteto (Cursor) · Cursor, with a Claude Code adapter

/poteto-mode routes a request to one of 22 playbooks; there is no single pipeline. This lane is our synthesis of the feature, bug-fix, opening-a-pr, babysit and shipping playbooks.
Order, per the authorrecommended in docs; nothing enforces it
Each playbook is an ordered step list the agent copies into a todo list. Feature: trace, /architect, four-item checkpoint, delegate, verify, small commits, /interrogate if contested, open PR ( feature). babysit, land and /reflect are separate requests. The guide follows the same chain: "Read the pages in order the first time." The author refuses plans and specs, not process: "the best spec is code."
poteto-modeskill
feature or bug-fixplaybook; poteto-mode matches one to the task
opening-a-prplaybook
babysitplaybook
shippingplaybook
reflect or correctskill; the human types either command
The human asks for PR status or to babysit.
The operator says to land.
The human runs /reflect or /correct. No playbook step leads here.

Matt Pocock · any agent (Claude Code, Codex, Copilot, Gemini CLI)

Small skills the human types. No orchestrator, no hooks, and no script runs in any step. A router skill, /ask-matt, names the next command and stops.
Order, per the authorrecommended in docs, conditional; refuses tools that own the process
"/grill-with-docs → /to-spec → /to-tickets → /implement → /code-review → /retro" ( docs/engineering/implement.md). Spec and tickets are skipped for single-session work; /retro is optional after a smooth build; prototype and /pr sit outside the main flow. A static table of steps would "be wrong for most situations" ( docs/engineering/ask-matt.md).
grill-with-docsskill
prototypeskill; /handoff carries the context out and back
to-specskill
to-ticketsskill
implement or implement-specone of two skills; the human picks
code-reviewskill; called by implement or implement-spec
prskill; the agent loads it when writing a PR
retroskill
Taken only when a question from the grill cannot be settled in conversation and needs running code (state, business logic, a UI you have to see). Otherwise the grill goes to To-spec or Implement.
The spec has been published to the tracker. /to-tickets can also run from the conversation alone, with no spec.
The human approved the breakdown and the tickets are published. The human then picks one of two ways to build: /implement per ticket (clear context between each) or /implement-spec for the whole graph.
Reviewed work is going up as a pull request and the agent writes a PR body. No skill states this transition.
The human chooses to look back, usually after a build that went sideways. It may be skipped after a smooth build. Run in the session being reviewed, before clearing.
The grilled work will not fit one agent session or context window and must be split across several sessions.
manual: multi-session build
The work is not a multi-session build (fits one context window); skip spec and tickets and build in the same session.
manual: small work
The prototype has answered its question and the human wants the answer in the original grilling thread.
manual: handoff back

Every (Kieran Klaassen, Trevin Chow) · Claude Code, Cursor, Codex and 11 more

One plan file grows from requirements to units; review traces back to its IDs. The Compound step writes down what the next change should not have to rediscover. Order shown is the one the /lfg command runs; there Brainstorm is an optional route and Compound runs only when the work corrected a wrong belief.
Order, per the authorrecommended in docs; the lists disagree
README: "The core loop is six steps: brainstorm the requirements, plan the implementation, work through the plan, simplify what you wrote, review the result, then compound the learning". The older guide on every.to has four: "Plan → Work → Review → Compound → Repeat". docs/guides/README.md chains brainstorm, plan, work, compound and calls review and simplify on-demand. Ship appears only in /lfg, which runs Compound before the PR; the /ce-work guide puts it after shipping. Typed by hand, nothing enforces any of these orders.
ce-brainstormskill
ce-planskill; ends by invoking ce-doc-review
ce-workskill
ce-simplify-codeskill
ce-code-reviewskill
ce-compoundskill
lfgskill; chains ce-test-browser, ce-commit-push-pr and ce-babysit-pr

Sisyphus Labs · its own omo binary; OpenCode and Codex plugins

Formerly oh-my-opencode. A typed keyword selects the mode. Shown is the opt-in written-plan path in the native edition: /ulw-plan, then /ulw-execute. The OpenCode edition has the same step order with different reviewers and verifier.
Order, per the authorrecommended in docs; code forces continuation, not order
The default is the bare keyword: "just type: /ultrawork … The agent figures everything out." The path drawn here is offered as "Want more control? Run /ulw-plan for interview-based planning, then /ulw-execute" ( overview.md). Code restricts when the plan-review agents can be spawned, and re-injects a continue prompt while the plan has unchecked boxes. Nothing in code checks the step order.
ulw-planskill
ulw-executeskill
memory componentharness code on session events; no skill or command
Reviewer approves unconditionally, or approves with only notes; user then starts /ulw-execute separately.

Roberto Mello · Claude Code, OpenCode, Gemini CLI, Cortex Code

Extends Compound Engineering. The plan is an epic with child issues ("beads") in the Beads tracker, not a file. A hook asks a subagent to log what it learned before it stops, but does not check that it did.
Order, per the authorrecommended in docs; the human types each command
"Most of the time, you type three commands": /lavra-design, /lavra-work, /lavra-ship, with /lavra-qa optional for web apps ( README.md). Inside /lavra-design the phases chain: "Brainstorm → Plan → Research → Revise → CEO Review → Eng Review → Lock". Review and the fix loop run inside /lavra-work. /lavra-quick is a shortcut for small tasks.
lavra-designcommand; chains six phases
lavra-workcommand; routes to single, sequential or parallel
lavra-qacommand; optional
lavra-shipcommand
hooks.jsonhook configuration: four harness events, no command
Human types /lavra-work after phase 6 locks the plan.
The project has a UI and the human wants it tested.
Human types /lavra-ship after QA.
There is no UI to test.
manual: no UI

Hyper planning loop

this project · proposed, not built

For reference: the loop proposed for hyper, run at every level (workstream, epic, task, step).

Planning questions each stack answers

Explicit: a named artifact or section, with a gate. Implicit: done inside another step, with nothing to check.

StackRequirementsCurrent stateDesignTask breakdownVerify against requirementsLearning kept
Superpowersgoals and non-goals in the design doc; no criteria list"Look Before You Ask" inside /brainstormingdesign doc behind a hard human gate/writing-plansreviews and tests; no requirement-by-requirement checkledger deleted at the end
pstackgoal restated; a done check is suggested, not requiredmechanism confirmed at runtime before designarchitect, arena, prototypefour-item checkpoint; plan file only for multi-PR workagainst the stated done check, by a non-author; no requirement list to tracereflect and correct; run by hand
AI Hero skillsspec issue with user stories; criteria per ticketconditional, in /to-spec and /to-tickets: "If you have not already explored the codebase, do so"test seams and an Implementation Decisions section/to-tickets, approved by the humanSpec axis of one review pass; no acceptance run/retro; advisory
Compound EngineeringProduct Contract with requirement IDsresearch in Brainstorm (grounding scout) and Plan (repo-research-analyst)Key Technical Decisions in the planImplementation Units with IDs, files, dependencies; no code checks that every requirement maps to a unitreview flags an unaddressed requirement when the plan is given explicitly; /ce-work, the implementer, re-checks the Definition of Done itselfCompound; conditional under /lfg, otherwise typed by hand
omoideal-state rows IS-n in the draft; no separate documentGround: cited findings and GAP-n rowsan approach field; no design artifacttodos in waves with a dependency matrixfinal row F4 checks each IS rowautomatic memory; no step, nothing to check
LavraRequirements and Non-Requirements on the epicresearch agents run inside Plan; deeper research off by defaultLocked Decisions; no design documentchild beads, DAG validatedper bead; the epic requirements are not recheckedmemory file; a hook asks, nothing checks
Hyper planning loopDefineBaselineDesignDecomposeVerify, at every levelnot in the proposal

Mechanisms worth taking, and gaps

StackWorth takingGaps
Superpowers
  • On-disk ledger with a resume rule; every solo decision recorded as ruling, reason, cost if wrong.
  • Bounded fix loop: 5 rounds, escalate the model, then the controller rules.
  • Briefs, reports and diffs travel as files, so the controller context stays small.
  • No learning kept between pieces of work.
  • One plan, one worktree, tasks strictly in sequence.
  • No requirement-by-requirement check at the end; the final reviewer asks only whether all planned functionality is present.
pstack
  • Only a non-author verdict counts, and an older verdict is rechecked against git patch-id.
  • A finding survives only if a rerun proves it.
  • Fix a repeated mistake at the highest level that works, and prove the new check fails on the old mistake.
  • No requirements artifact, so nothing to trace the final verdict to.
  • Nearly every skill is manual; rigor depends on the operator typing /poteto-mode.
  • Step order is prose in 22 playbooks; nothing enforces it.
AI Hero skills
  • Interview in rounds: all unblocked questions at once, each with a recommended answer.
  • Test seams agreed with the human before any test exists.
  • Standards review and spec review run apart and are never merged.
  • Nothing drives the order; the human types each command.
  • Review is one pass with no stop condition.
  • No dedicated current-state step (exploration is conditional), no acceptance check, merge not covered.
Compound Engineering
  • One plan file with stable requirement and unit IDs that review traces back to.
  • Learning ladder: test or lint rule, then coding standard, then written note. Take the first that works.
  • Review receipt checked before push in standalone /ce-work; skipping takes an exact phrase (a prompt rule, not code).
  • No replan route: a plan error found in Work is fixed in place or stops the run as blocked. Plan can suggest /ce-brainstorm when scope is unsettled, only if the human confirms.
  • Current state is researched into scratch dossiers that are deleted after the plan is written; the plan keeps decisions, risks and an optional sources section.
  • Skills are long chains of reference files; the model must read them in order.
omo
  • Ideal-state and gap rows: every todo closes a gap, every ideal-state row is proven at the end.
  • A done claim passes only when an independent agent fails to refute it; the orchestrator just records.
  • Another review round runs only if the last one changed something.
  • The plan is the only document; no design artifact.
  • Very large prompts (the execute skill is about 29 KB).
  • The two editions differ in who reviews the plan and who verifies the work.
  • Done means no unchecked boxes: a plan whose remaining boxes are all marked [~] (blocked) reads as complete, and no code reads evidence or verdicts.
Lavra
  • Every decision typed Locked, Discretion or Deferred; reviewers get the Locked list so they do not flag planned gaps.
  • goal-verifier levels: exists, substantive, wired. Catches stubs and unconnected code.
  • Parallel waves by file ownership: beads that touch the same file get a dependency; subagents may not commit.
  • Gates are checklists the agent fills in about itself; the stop hook asks for a learning and never checks for one.
  • Nothing rechecks the epic requirements after the beads pass.
  • Ship ends at the PR.
  • Two hook scripts call code that is not there: extract-bead-context.sh looks for sanitize-content.sh one directory too high and exits with an error; check-memory.sh calls a function that only the installer defines.
Hyper planning loop
    • No step keeps what was learned for the next piece of work.

    My reading