Orchestrating werkstoff with superpowers and the official plugins

werkstoff's thirteen plugins, obra/superpowers, and Anthropic's official plugin set were built independently, and they overlap far less than their descriptions suggest. This catalog records how they compose in one session: which pieces own a whole task, which drop into somebody else's workflow, and which handoffs are already wired so nobody orchestrates them twice by hand.

Three roles

Three different things are installed, and they stack rather than compete. New here? Start here is the shortest path; this page is the map behind it.

layer	what it supplies	how to install
werkstoff — thirteen plugins	specialised inspectors and enforcers, each refusing to speak outside one failure mode	/plugin marketplace add Anselmoo/werkstoff then /plugin install <name>@werkstoff
superpowers — 14 skills, no agents, no commands	the loop shape: brainstorm, plan, TDD, request review, verify before completion. Never the domain judgement	/plugin install superpowers@claude-plugins-official
the official Anthropic plugins	named, tool-scoped reviewer agents that a command orchestrates	/plugin install pr-review-toolkit@claude-plugins-official (and siblings)

Two things that catch people out. superpowers ships one SessionStart hook and nothing invocable as an agent or slash command — any instruction to dispatch it as one is wrong. And claude-security sets disable-model-invocation: true, so the model can never reach for it on its own.

Within werkstoff, eight of the thirteen target one distinct failure mode each — andon on handoffs between stages that were never proven, befund on a repo that cannot describe its own health, zeugnis on assertions, contracts and dependency manifests that look right and are not, zirkel on reasoning stages silently skipped under pressure, cupertino on interfaces decorated instead of designed, cli-scaffold on CLIs that are not production-grade, and passung on the narrow case of two or more valid, undocumented variants of the same convention coexisting, and lehre on code written against a doctrine nothing enforced at write time. The ninth, takt, ships no skills at all: it is one PreToolUse hook that denies an edit or a dispatch running ahead of a beat the repository declared it depends on, turning the sequencing this catalog documents into a refusal rather than a suggestion. The tenth, nacharbeit, points the same discipline at the other nine: it reviews and reworks a plugin's own skills, agents, hooks, scripts, viewers, manifest and docs against the official Anthropic standard, and is the only plugin whose object is a plugin rather than the application it is installed against. The eleventh, matrize, targets a skipped decision phase: a design system re-guessed ad hoc per project instead of derived once from exemplars someone actually admires, named, and struck into every target — a DTCG token file, a stylesheet, a Tailwind config, and a sketchbook a non-technical decision-maker can approve. The twelfth, arbeitsplan, is the compiler for a beat declaration: it turns a stated problem into a workflow spec and the takt beats that order it, then runs the spec as a redundant swarm — N candidates over one scope, exactly one landed. The pairing with takt is the point. takt could not be used because nothing authored its declaration; nothing authored it because the format is a thing you write by hand, and nobody did. The thirteenth, spur, targets a result nobody can trace back: one traced run records what each step called, read and wrote, and whether it read what the step before it wrote.

superpowers is process discipline. It ships 14 skills, zero agents, zero commands, and one SessionStart hook — so any agent, in any plugin's workflow, can execute it. It supplies the loop shape (brainstorm, plan, TDD, request review, verify before completion), never the domain judgement. It is authored at github.com/obra/superpowers and distributed through the official marketplace; it is not one of the 39 plugin directories inside anthropics/claude-plugins-official. Nothing in it can be invoked as an agent or a slash command, and any instruction to do so is wrong.

The Anthropic-internal plugins ship named, tool-scoped agents that a command orchestrates. pr-review-toolkit holds 6 agents behind one command, feature-dev 3 behind one, code-modernization 8 behind ten, and claude-security 8 behind none. The agents are the reusable part; the command is the pipeline that happens to sequence them.

They compose because they occupy different layers: werkstoff supplies the inspector, superpowers supplies the loop the inspector runs inside, and the official plugins supply named reviewer agents to fill a beat neither of the other two covers.

Orchestrators and leaves

This is the one distinction the rest of the catalog depends on.

An orchestrator is a fixed sequence whose middle steps read artifacts earlier steps wrote. It cannot be dropped into another workflow, because a step invoked without its predecessor's artifact either refuses or fabricates. Choose an orchestrator only when it owns the whole task.

A leaf is dispatchable at any moment from a scoped prompt, carries no pipeline state, and returns a result rather than advancing a ledger. Leaves are what compose into another workflow's beats and gates.

werkstoff

Orchestrator	Why it cannot be dropped mid-flight
andon-loop	Owns and persists the OKF ledger; a pass is a traversal of the whole stream
zeugnis-cycle	Re-runs audits to convergence under a pass cap enforced by scripts/cycle_engine.py
zeugnis-mutation-harden	Prepares a fresh archive copy, runs the mutation tool as a background script, then proves, re-measures and reports; every step reads the files the previous one wrote under analysis/zeugnis/mutation/<runId>/
befund-autopilot	CHECK -> PLAN -> approval gate -> FIX+VALIDATE, each phase consuming the last
befund-transform-brief	Gated on stage_graph.json; degrades to "Ready-with-gaps" without it
befund-transform-execute	Applies exactly one human-authorized phase of MODERNIZATION_BRIEF.md
zirkel-solve	Clarify -> Explore -> Decompose -> Execute -> Revise as one fixed pipeline
cupertino-handbook-fix	Applies mechanical findings from a prior cupertino-handbook-check pass
cupertino-repair	Objective, baseline, approved changeset, scoped apply and verdict share one run directory under .cupertino/repair/<run>/; a hook limits each edit to the active approved item, so an edit made without the earlier steps is denied
/passung-map, /passung-canonize, /passung-brief, /passung-align, /passung-verify	Every one reads analysis/<area>/ artifacts an earlier command wrote
nacharbeit-review	Bakes its args, calibrates a finder against planted fixtures and a sealed hold-out, then finds, routes, verifies and synthesizes; every later step reads what the calibration froze
nacharbeit-fix	Opens the fix lock, snapshots the plugins about to change, applies the haiku and sonnet tiers under a PreToolUse guard, and releases the lock only after post-checks and a contract diff
arbeitsplan-compile	Scopes the problem, derives acceptance criteria, proves the write scope and picks patterns, then writes the spec every later phase reads; a phase invoked without it has no contract to run under
arbeitsplan-run	Opens the run-scope lock, fans candidates out into worktrees, applies the per-batch breaker, referees blind and lands exactly one diff; every step consumes what the last one wrote
arbeitsplan-design	Snapshots the agent types that exist, designs node by node, validates and preflights the design, and binds approval to its hash; the handoff it ends with reads that snapshot and that hash
arbeitsplan-waves	Installs an approved wave design, then launches and resumes it from the primary checkout; every launch reads the state the last one left, and a wave run cannot start without the install
matrize-decode	Fans reference-decoders out under a circuit breaker, then has each card re-derived from its cited source by a blind referee; a card that skips the referee is an unverified claim
matrize-brief	Stops outright if any discovery artefact is missing, and its signed approval block is what the three build methods read as their entry gate
matrize-emit	Runs the committed formatters against a tokens.json the earlier phases wrote; there is nothing to format before they have
andon-status, zeugnis-status, befund-status, nacharbeit-status, matrize-status, arbeitsplan-status	Report on what has already run; they have nothing to say outside their own pipeline (/passung-status behaves the same way)

Everything else in werkstoff is a leaf. That covers all of zirkel's reasoning skills, all of zeugnis's auditors, cupertino's technique skills, cli-scaffold's paradigm and doctrine skills, befund's finding skills, lehre's gauge and validate skills, nacharbeit-lint (the mechanical rubric, no tokens), spur-trace (one run traced, nothing read from an earlier step), matrize's collect, name, retrofit and dolmetsch, every *-preflight, and every named agent across all thirteen plugins — including nacharbeit's component-finder and fix-verifier, which exist precisely so a session without the Workflow tool can still dispatch one batch or verify one file from a scoped prompt.

Two leaves deserve calling out by name, because they are usually assumed to be pipeline-bound and are not. andon-verify states "Never write to the ledger" and andon-propose states "never write to the ledger yourself -- andon-loop persists this". Both therefore run standalone from a scoped prompt: andon does not have to be adopted wholesale to be useful, and its adversarial tribunal is available as a verification beat inside any other workflow.

The official set

Orchestrator	Leaves it sequences
/modernize-* (ten commands)	legacy-analyst, business-rules-extractor, version-delta-analyst, architecture-critic, security-auditor, test-engineer (plus scaffolder and uplift-migrator, which are not standalone)
/review-pr	code-reviewer, code-simplifier, comment-analyzer, pr-test-analyzer, silent-failure-hunter, type-design-analyzer
/feature-dev	code-architect, code-explorer, code-reviewer
create-plugin	agent-creator, plugin-validator, skill-reviewer

The six pr-review-toolkit agents declare no tools: key, fetch no PR themselves, and are diff-shaped — which is exactly what makes them droppable into a werkstoff review gate. claude-security is the exception on the other side: it sets disable-model-invocation: true, so the model can never propose it, and six of its eight agents state they are not for direct invocation (as of claude-security@0.11.0).

The four beats

Most multi-plugin work fits the same four beats. Name leaves at each beat, and reach for an orchestrator only when one of them owns the task outright.

Inspect and research. zirkel-clarify-scope before any work begins, then befund-stage-map for the real import graph, befund-arch-health, zirkel-map-relationships and zirkel-ground-evidence for grounding, and the official legacy-analyst or code-explorer where the code is unfamiliar. cupertino-backwards goes first in any design-shaped task — before cupertino-focus or any other cupertino technique.

Split into workstreams. superpowers brainstorming then writing-plans produce the plan; zirkel-decompose-chain produces the dependency order; zirkel-explore-branches produces genuinely distinct options before one is picked; zirkel-negotiate-tradeoffs settles the fork the plan cannot.

Execute in parallel. superpowers dispatching-parallel-agents supplies the only parallel primitive that matters, verbatim: "Multiple dispatch calls in one response = parallel execution. One per response = sequential." Pair it with subagent-driven-development, test-driven-development, and using-git-worktrees for isolation. Leaf work at this beat: scaffold-cli under the cli-architecture doctrine, cupertino-council at UI build-time before any code is written, and befund-idiom-fix for mechanical rewrites.

Fixing or extending something that already exists belongs to the same beat but is not a leaf: cupertino-repair owns it as an orchestrator, with a baseline taken first, an approved changeset and a verdict at the end. Reach for it instead of cupertino-council or cupertino-review when the request is "fix this dashboard" rather than "design a new one".

Verify. andon-verify proves one named wire through whichever of seven strategies its type calls for; zeugnis-assertion-audit asks whether the tests would catch a mutation; zeugnis-contract-drift checks contracts after a refactor; superpowers requesting-code-review and verification-before-completion close the loop; and the pr-review-toolkit agents cover the diff-shaped checks werkstoff has no equivalent for, silent-failure-hunter and type-design-analyzer in particular.

Worked examples

Naming leaves in prose is not the same as showing what to actually type. Three real recipes from the catalog, quoted unedited, each pairing a werkstoff leaf with a leaf from one of the other two sources named in this document's title.

superpowers, at the "Execute in parallel" beat — from execute-plan-across-parallel-workstreams:

break this plan into independent workstreams -- tell me what actually depends on what
and what can truly run in parallel

That single ask dispatches zirkel:zirkel-decompose-chain to derive the split, then hands each independent workstream to superpowers:subagent-driven-development and superpowers:dispatching-parallel-agents, with andon:andon-verify proving each one before it counts as done.

code-modernization, at the "Inspect and research" beat — from same-stack-version-uplift:

we're moving this codebase up a major version of the same stack. Which breaking
changes actually affect our code?

code-modernization:version-delta-analyst is dispatched directly — modernize-brief.md sanctions exactly this, and the eight-stage pipeline around it would refuse without artifacts this task has no reason to produce. befund:befund-code-idiom then judges idioms against the version this repo actually targets, and befund:befund-idiom-fix applies only the mechanical fixes.

pr-review-toolkit:code-simplifier, at the "Verify" beat — from audit-against-documented-conventions:

extract the discrete, checkable rules this repo's own documentation states, and audit
the code against them

code-simplifier runs last in that recipe, deliberately: it simplifies the now-aligned code only after befund has audited the documented rules and passung has canonized the undocumented ones, so nothing gets simplified twice.

What is already wired

Three handoffs exist in the skill definitions. Orchestrating them by hand duplicates work and can double-apply a fix.

• befund-autopilot hands FIX+VALIDATE to andon:andon-loop once its approval gate passes, and never edits source itself. Without the andon plugin installed it reports that the plan is ready and stops.
• befund-idiom-fix and befund-transform-execute both declare their own changes unverified and hand off to andon:andon-verify — or andon-loop for a ledger-recorded proof — rather than self-verifying.
• befund-autopilot's autopilot-zeugnis-optional rule attempts zeugnis's audit skills only when zeugnis actually appears in the session's skill listing, reports "zeugnis not installed" plainly when it does not, and never fabricates zeugnis-shaped findings to fill the gap.

Reading this catalog

The entry point stops here. Each reference below covers one decision a session actually has to make.

• the prompt catalog — the task-indexed prompt catalog: what to say, per task shape, to get the right combination dispatched.
• references/routing.md — which of the four overlapping pipelines owns a task, and which brief must not be signed alongside it.
• references/gates.md — the approval, verification and hook gates each family enforces, and where they collide.
• references/delegation.md — model tiering and dispatch shape for parallel subagent work.
• references/hazards.md — a catalog of composition hazards: what breaks when several hook-bearing plugins share a session.
• references/pairings.md — the pairing-indexed companion to the task catalog above: which two skills combine, and why.
• references/claude-md-block.md — a paste-in CLAUDE.md block that encodes these routing rules for a repo.

For the standards that govern the plugin definitions themselves rather than their composition, see ../plugin-authoring/README.md.