Superpowers and H·AI·K·U, Side by Side

Brainstorm and plan happen before any code lands. The plan is a distinct artifact the agent reads before executing tasks.

Discovery, elaborate, decompose all happen before the first hat fires execute. Unit specs are written, reviewed, and signed before any build hat sees them.

Helper agents do focused work in isolated workspaces. They don't step on each other; each one owns a slice.

Wave dispatch fans out parallel subagents in isolated git worktrees. Each runs its hat against its unit, terminates, merges back.

Explicit review checkpoints between tasks. The agent doesn't get to declare its own work done.

Verifier hat is structurally separate from the doer. Adversarial review agents fire as their own subagents. feedback-assessor decides closure independently.

Tests must pass before work moves forward. The agent can't talk its way past a failing verification step.

quality_gates: on each unit spec are executable commands. Non-zero exit blocks the advance; the engine enforces it, not the agent.

Jesse's framing: scaffolding for things the model can't yet do reliably on its own. Worth removing as models improve.

Same argument made at length in H·AI·K·U Is a Harness. Every layer of the engine encodes an assumption about a current model limit; the reflection loop is wired to flag the ones that have gone stale.

Front-loaded. When a skill activates, the whole skill body lands in the agent's context — workflow, checklists, hard gates. The agent executes from context.

Drip-fed. The agent calls haiku_run_next, gets back one action, executes it, calls again. The plan lives on disk; the agent is stateless between calls.

The agent. It follows the skill's flowchart, picks up the next step, and proceeds. Hard gates and loud framing keep it on the rails.

The engine. It reads on-disk state, walks a deterministic state machine, returns exactly one structured action. The agent never has the "what now?" decision.

Context compaction or /clear is fatal mid-run. Start over. Jesse's design keeps sessions short enough that this rarely bites.

Compaction, /clear, crash, machine swap — irrelevant. The next tick reads disk and tells the agent what's next. Nothing was in the conversation to lose.

Continuous partnership is the product. Brainstorm together, review per task, code-review between tasks. The human stays in the loop throughout execution.

Front-loaded into the spec. The human works hard upstream so execution can run as dark as the work calls for. Per-stage gates let you dial supervision back in where needed — dark factory is the ceiling, not the mandate.

Superpowers is software-focused by design. H·AI·K·U ships twenty-four studios — software, gamedev, hwdev, libdev, marketing, legal, finance, HR, sales, product-strategy, compliance, customer-success, incident-response, documentation, quality-assurance, vendor-management, security-assessment, training, dev-evangelism, migration, executive-strategy, data-pipeline, ideation, and project-management. Each carries its own stage sequence, hat library, and review-agent lineup. Different leverage point.

A product launch crosses marketing, engineering, and legal. H·AI·K·U treats that as first-class — multiple studios under one parent with sync points. State on disk means a researcher can start it, a designer can pick up design, a developer can take construction, a security reviewer can gate release. Each human opens a fresh session; the engine reads state; next action is right there.

A public browsable catalog of in-flight work. Stakeholders can walk the history, read specs, inspect artifacts, and approve checkpoints without running an AI coding tool. The intent directory is a portfolio, not a log.

Has a surface — the skills library is browseable, and Jesse's craft on the interaction shape is visible. Built around the engineer working continuously with the agent.

Local SPA per intent. Review sessions render diffs, specs, annotations, and gate verbs in a browser tab. Questions and design-direction requests route there. The browse view shows every intent in the repo with its current stage and open feedback — a portfolio across an entire team's work. A designer leaving a comment, a PM dropping an answer in a question modal, a QA lead approving a gate — none of them have to learn the CLI. Their input lands as feedback the engine treats as first-class at the next tick. Drift flows the other direction: out-of-band file edits get caught pre-tick and reconciled before the agent moves. Same engine, three loop positions per stage — in, on, off — set at elaborate time.