claude-swe-workflows

claude-swe-workflows

A system of composable software engineering workflows for [Claude Code][cc]. Plan projects, implement tickets, and run quality passes — from a single ticket to a multi-batch project, using the same layered architecture.

Installation

claude plugin marketplace add https://github.com/chrisallenlane/claude-swe-workflows.git
claude plugin install claude-swe-workflows@claude-swe-workflows

Layered Composition

The skills are arranged as layered composition — higher-level skills invoke lower-level ones. Enter at the layer that matches your task. The deepest stack:

/lead-project                              ← autonomous tech lead (decides what to do next)
└── invokes any skill below
    /implement-project                     ← full-lifecycle project execution
    └── /implement-batch                   ← one batch of related tickets
        └── /implement                     ← one ticket, end-to-end
            └── SME agents                 ← language-specific specialists

Three other entry points orchestrate bounded autonomous loops:

• /lead-bug-hunt — loops /bug-hunt → /implement-batch until bugs converge below a severity floor.
• /lead-refactor — /refactor → loops /review-arch + /implement-batch → /refactor.
• /lead-review — runs every /review-* sub-skill once.

Planning feeds implementation: /scope-project → /implement-project, or /scope → /implement. Supporting skills (/think-*, /review-*, /bug-*, /tidy-*) compose into any of the orchestrators above or run standalone.

Namespaces

Skills are grouped by namespace for discoverability. Each namespace gathers skills with a related purpose.

Namespace	Purpose	Skills
/lead-*	Autonomous orchestrators	/lead-project, /lead-bug-hunt, /lead-refactor, /lead-review
/implement-*	Implement tickets (mutate the working tree)	/implement, /implement-batch, /implement-project
/scope-*	Plan and produce tickets	/scope, /scope-project
/review-*	Advisory audits — no code changes	/review-arch, /review-test, /review-perf, /review-a11y, /review-health, /review-security, /review-release
/think-*	Reasoning support — no artifacts	/think-reframe, /think-brainstorm, /think-diagnose, /think-ach, /think-deliberate, /think-premortem, /think-scrutinize, /think-reflect
/tidy-*	Mechanical hygiene	/tidy-docs, /tidy-git
/bug-*	Find and fix bugs	/bug-fix, /bug-hunt
/test-*	Test-quality work	/test-mutation
(standalone)	Skills that don't share a namespace	/refactor, /pre-compact, /release

The /lead-* and /implement-* namespaces additionally share an autonomy discipline (commander's intent, pre-loaded options, pre-rebutted recommendations, risk budgets) — see references/autonomy.md. The /think-* namespace shares a design discipline (practitioner-sourced countermeasures to specific cognitive failure modes) — see references/think.md.

Choosing a Workflow

Not everything needs the full pipeline. Enter at the level that matches your task:

You want to...	Use
Drive a project to completion autonomously, deciding what to work on	/lead-project
Implement an entire multi-batch project autonomously	/implement-project
Implement a batch of related tickets	/implement-batch
Implement a single ticket or feature	/implement
Plan a multi-batch project with adversarial review	/scope-project
Plan a single feature and create a ticket	/scope
Fix a bug with diagnosis and root-cause analysis	/bug-fix
Proactively hunt for bugs before they're reported	/bug-hunt
Iterate hunt → fix until bugs converge below a severity floor (autonomous)	/lead-bug-hunt
Comprehensively refactor (tactical + architectural + tactical, autonomous)	/lead-refactor
Pressure-test a problem's framing before solving it	/think-reframe
Brainstorm approaches to a goal	/think-brainstorm
Reason about why a phenomenon is happening	/think-diagnose
Narrow among competing hypotheses against evidence	/think-ach
Make a hard decision with adversarial deliberation	/think-deliberate
Imagine how a plan could fail, or how a hypothetical catastrophe could hit a running system	/think-premortem
Scrutinize an idea or plan before committing to it	/think-scrutinize
Reflect on a completed experience to update beliefs	/think-reflect
Clean up code quality (DRY, dead code, naming)	/refactor
Rethink module boundaries and architecture	/review-arch
Survey the test suite and surface gaps as tickets	/review-test
Verify test quality via mutation testing	/test-mutation
Tidy all project documentation	/tidy-docs
Pre-release readiness check	/review-release
Cut a versioned release (preflight + plan + execute)	/release
Audit web content for accessibility barriers	/review-a11y
First-pass strategic orientation on a repo	/review-health
Review performance (compute and/or web)	/review-perf
Perform a white-box security audit	/review-security
Run every review dimension autonomously (with optional backlog creation)	/lead-review
Tidy up the session before running /compact	/pre-compact
Clean up local git state (stale refs, merged branches)	/tidy-git

Rules of thumb:

• Open-ended work where the next step depends on the outcome of the last? /lead-project
• Multiple batches of tickets forming a project? /implement-project
• One batch of 2+ related tickets? /implement-batch
• One ticket? /implement (or /bug-fix if it's a bug)
• Not sure what to build yet? Start with /scope or /scope-project

Skills

One-line summaries grouped by namespace. Click through to each skill's detailed README.

/lead-* — Autonomous orchestrators

• /lead-project — Autonomous tech lead. Runs an OODA loop over project state given a commander's intent, invoking lower-level skills until end-state is met or it pulls an andon cord. (details)
• /lead-bug-hunt — Loops /bug-hunt → /implement-batch until bugs converge below a stated severity floor; runs /review-test on the new reproducing tests at termination. (details)
• /lead-refactor — Three-phase comprehensive refactoring: tactical /refactor → loop of /review-arch + /implement-batch until convergence → final tactical /refactor. (details)
• /lead-review — Runs every /review-* sub-skill autonomously with an operator-set toggle for whether sub-skill ticket proposals are written to the tracker. (details)

/implement-* — Working-tree mutators

• /implement-project — Full-lifecycle project execution. Implements batched tickets, runs the quality pipeline (refactor, review-arch, review-test, tidy-docs, review-release), produces a review-ready branch. (details)
• /implement-batch — Plans execution order of a batch of tickets, implements each via /implement autonomously, runs cross-cutting /refactor and /tidy-docs passes. (details)
• /implement — Single-ticket development cycle: requirements → planning → implementation → QA → code review → documentation. Dispatches to language SMEs. (details)

/scope-* — Planning

• /scope-project — Plans a multi-batch project through layered adversarial review loops (UX, optional security/performance, implementer). Produces batch-tagged tickets ready for /implement-project. (details)
• /scope — Iterative problem-space exploration that produces a single detailed ticket. For one feature, bug, or refactor proposal. (details)

/review-* — Read-only audits

All /review-* skills are advisory — they audit and propose, never mutate.

• /review-arch — Architectural analysis via noun analysis; produces a target blueprint and proposes tickets for the recommended work. (details)
• /review-test — Five-phase test-suite survey: unit, integration, E2E (browser, webapps only), fuzz, test quality. Proposes a ticket structure for gaps. (details)
• /review-perf — Performance review across compute (algorithms, profiling) and web (caching, asset delivery, Core Web Vitals) domains. (details)