agent-workflows

Simplify and clean up code after generation. Use proactively after writing or modifying code.

Expert code review specialist. Proactively reviews code for quality, security, and maintainability. Use immediately after writing or modifying code.

Run the full diverge-converge-premortem pipeline as a single invocation. Use for major architecture decisions and new feature exploration.

Run stress-test then premortem with security focus. Use before shipping security-sensitive changes.

Binary search for root cause. Defines a search space and pass/fail oracle, then iteratively tests midpoints — halving the space each step until the root cause is isolated. Works across git history, configuration, dependencies, or code modules.

You are facilitating a structured brainstorming session.

Comprehensive code review of uncommitted or recently committed changes. Reviews for security, quality, and maintainability, then reports findings by severity.

Workflow Pipeline Builder. A meta-workflow that takes a goal and designs which existing workflow skills to chain together, in what order, with what parameters. Spawns agents to independently propose different workflow compositions for the same goal. The only workflow that operates on the WORKFLOW LAYER rather than the problem layer. Produces a recommended pipeline with rationale.

Constraint Inversion — What-If Removal. Takes a design with stated constraints and spawns N agents, each removing or inverting ONE constraint to explore what becomes possible without it, then synthesizes findings into a constraint dependency map that reveals which constraints are truly load-bearing vs merely assumed.

Specification Generation from Examples. Takes a set of examples (API calls, test cases, user stories, input/output pairs) and spawns N agents to independently INFER the specification that would produce those examples. Each agent works bottom-up: what rules, constraints, invariants, and edge cases does this behavior imply? Agents don't see each other's inferences. Synthesize by comparing: where agents infer the same rule, it's likely correct; where they diverge, the examples are ambiguous or underconstrained. Output is a draft specification with confidence annotations.

Structured debate and refinement using Agent Teams. Takes divergent findings (from /diverge or any independent research) and spawns a team where teammates advocate for different positions, debate trade-offs, and converge on a refined synthesis.

Structural recombination of existing designs. Takes 2-3 prototypes or design approaches and spawns N agents to create HYBRID designs, each with a different "dominant parent" whose architecture leads while grafting specific elements from the others.

Blast Radius Impact Mapping. Takes a proposed change (diff, migration, dependency upgrade, config change) and spawns N independent agents, each tracing impact through a different propagation path. No agent sees others' findings. Synthesizes into a combined blast radius map showing first-order, second-order, and third-order effects radiating outward from the change point.

Essence Extraction via Progressive Compression. Takes a large artifact and runs it through a chain of compression agents where each must compress the previous output by ~50% while preserving the most important information. The key insight: the DROPS at each compression layer — what each agent chose to cut — reveal the priority hierarchy. The waste product IS the signal.

Divergent prototyping. Spawns N independent agents in isolated worktrees to explore different implementation approaches for a PRD, then synthesizes results.

Multi-perspective divergent research. Spawns N independent agents with uncorrelated context windows to explore a question from different angles, then auto-synthesizes findings into a unified analysis and PRD.

Dependent co-design of coupled subsystems. Spawns one agent PER SUBSYSTEM in isolated worktrees, all sharing a single evolving interface contract file. A coordinator merges contract proposals and broadcasts updates. Agents iterate until the contract stabilizes. Produces N co-designed subsystems plus the negotiated contract.

Single-task execution loop with structured context handoff. Enforces the discipline of plan → execute → simplify → review → close. Uses Beads (`bd`) for task tracking so context survives across sessions without artifact clutter. A new session runs `bd ready` and picks up exactly where the last one left off. Supports parallel execution of independent beads via worktree-isolated subagents.

Competitive Problem Decomposition. Spawns N independent agents, each proposing a DIFFERENT decomposition of a problem into subproblems using a distinct structural lens. One decomposes by user journey, another by data flow, another by failure domain, another by team boundary, another by deployment unit. Synthesizes into a comparison of decomposition strategies with convergence analysis and a recommended framing.

Evaluate an MCP tool's agentic usability via parallel test scenarios plus a meta-reflection pass, producing a scored improvement report

Parallel Strategy for System Transitions. Spawns N independent agents in isolated worktrees, each implementing a DIFFERENT migration strategy for the same old-system-to-new-system transition. The path is the variable, not the destination — all agents implement the same end state but via different transition paths. Each agent prototypes the critical path (the riskiest step) of their strategy, not the full migration. A lead agent then synthesizes all strategies into a comparison across rollback safety, data integrity, downtime, and coordination cost.

Cancel or pause a PRD build run

Resume a paused or interrupted PRD build run

Show PRD build orchestration status

Decompose a PRD into parallel work units and build them with independent agents

Run /prd-build over multiple PRDs with full worktree lifecycle (create, dispatch, FF-merge, cleanup). Single-command dispatch from one session — sequential or parallel.

Prospective Failure Narratives. Spawns N independent agents, each writing a narrative from the future where the project FAILED for a different root cause. No agent sees others' failure stories. A lead agent then synthesizes all failure narratives into a structured risk registry with severity ratings and mitigations.

Independent Verification by Reimplementation. Spawns N agents in isolated worktrees to implement the SAME specification independently, with no knowledge of each other's code. Compares outputs to produce a convergence/divergence map that reveals where the spec is clear, where it is ambiguous, and what it fails to specify at all.

Run diverge → converge → premortem pipeline to produce a risk-annotated PRD

Build-order planning via competing sequencing strategies. Takes a chosen design (from /diverge-prototype or any architecture decision) and spawns N independent agents, each proposing a different build-order strategy. Each agent produces a sequenced implementation plan with milestones, dependencies, and risk assessment. Synthesizes into a recommended build plan.

Review changed code for reuse, quality, and efficiency, then fix any issues found.

Parallel Adversarial Attack Surface Analysis. Spawns N independent agents, each tasked with BREAKING a system from a different attack angle. No agent sees others' findings. Synthesizes into a vulnerability map with severity ratings.

5 hooks across 5 events