Orchestrate autonomous software engineering workflows across planning, implementation, code review, bug hunting, refactoring, QA, and release management using a suite of specialist agents and structured thinking skills.
Methodical UX advocate that reviews a draft ticket set for user-experience cogency before implementation begins. Walks a fixed seven-concern spine (coherence, completeness, mental-model fit, implicit knowledge, failure paths, power/novice tension, orientation), auto-detecting target type (CLI / MCP / webapp / library) to choose what evidence to inspect. Used in /scope-project's first adversarial loop to surface UX issues as hard constraints before the implementer review.
Good-faith skeptic that identifies faults in an idea or plan. Spawned with a specific critical lens (technical, economic, operational, etc.) to surface fatal flaws, serious concerns, load-bearing assumptions, and minor issues. Used in scrutinization proceedings alongside an advocate that rebuts findings in good faith.
Project documentation maintainer
Quality assurance engineer
Pre-release scanner that audits code for release readiness across multiple quality dimensions
Proactive bug-hunting workflow. Assesses codebase risk through complexity, coverage, and structural analysis, then spawns focused investigators that write reproducing tests to validate suspected bugs. Thoroughness over speed. Advisory only — produces findings and proposes tickets; does not implement fixes.
Multi-ticket batch workflow. Takes a batch of tickets, plans execution order, implements each via /implement in autonomous mode, runs cross-cutting quality passes, and presents results for final review.
Full-lifecycle project workflow. Takes batched tickets, implements via /implement-batch, runs smoke tests, then executes a comprehensive quality pipeline (refactor, review-arch, review-test, tidy-docs, review-release). Maximizes autonomy with andon cord escape.
Iterative development workflow that coordinates implementation, refactoring, QA, and documentation agents to complete features systematically. Use when the user wants a full development workflow with quality checks.
Mutation testing workflow. Systematically mutates source code to verify tests actually catch bugs. Multi-session with progress tracking.
Uses power tools
Uses Bash, Write, or Edit tools
Based on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
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.
claude plugin marketplace add https://github.com/chrisallenlane/claude-swe-workflows.git
claude plugin install claude-swe-workflows@claude-swe-workflows
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.
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.
Not everything needs the full pipeline. Enter at the level that matches your task:
npx claudepluginhub chrisallenlane/claude-swe-workflows --plugin claude-swe-workflowsVerification-first engineering toolkit for Claude Code. 15 skills across a 5-phase spine (Investigate → Design → Implement → Verify → Ship), 8 specialist agents, an interactive setup wizard. Every skill has rationalizations + evidence requirements. Built for senior ICs and tech leads.
Structured engineering workflows for Claude Code.
Comprehensive skills library for Claude Code: planning, design, TDD, debugging, collaboration patterns, and proven techniques
Stack-agnostic agent skills for a disciplined, doc-driven feature/issue workflow: design, plan, execute by phases, review, audit, and ship — with a full internal review pack and merge gates.
Context-Driven Development plugin that transforms Claude Code into a project management tool with structured workflow: Context → Spec & Plan → Implement
Claude Code software delivery workflows packaged as namespaced skills and agents.