claude-swe-workflows

Project documentation maintainer

Quality assurance engineer

Pre-release scanner that audits code for release readiness across multiple quality dimensions

Coverage gap reviewer that identifies untested code paths, prioritizes by risk, and suggests refactoring for testability. Advisory only.

Fuzz testing gap reviewer that identifies functions suitable for fuzz testing and checks for fuzz infrastructure. Advisory only.

Mutation testing worker that applies code mutations one at a time and reports which tests catch them

Test quality reviewer that identifies brittle, tautological, and harmful tests. Reports redundant tests as informational only.

Web accessibility reviewer that identifies WCAG conformance gaps, prioritizes by impact, and recommends fixes. Advisory only.

Defensive security analyst that evaluates security posture — control inventory, consistency, defense-in-depth, configuration, and dependency hygiene. The defensive counterpart to the red-teamer. Advisory only.

Adversarial security analyst that attacks code from the attacker's perspective to find exploitable vulnerabilities

Architecture reviewer that builds domain models and produces target blueprints

Codebase risk assessor that cross-references complexity, coverage, structural risk factors, and git history to identify where bugs are most likely to lurk. Produces a ranked hotspot list for focused investigation.

Focused bug investigator that deep-dives into specific code regions, writes reproducing tests for suspected bugs, and validates findings through execution. Keeps valuable tests even when they invalidate a suspicion.

Bug root-cause investigator that traces failures, performs git archaeology, and produces diagnosis reports

Tactical code quality reviewer that identifies refactoring opportunities within existing architecture

Performance reviewer that identifies computational bottlenecks, benchmarking gaps, and optimization opportunities. Advisory only.

Software implementation planning specialist that decomposes complex problems into sequential, testable sub-tasks

Ansible automation and infrastructure-as-code subject matter expert

CSS subject matter expert

Docker and containerization subject matter expert

Go subject matter expert

GraphQL API design and implementation subject matter expert

HTML subject matter expert

JavaScript subject matter expert

Makefile optimization and best practices expert

TypeScript subject matter expert

Zig subject matter expert

Web performance reviewer that identifies network, caching, loading, and asset delivery issues. Analyzes structural performance from source code. Advisory only.

Argues in good faith for an assigned position in adversarial proceedings. Used by /think-deliberate (arguing for one option among many) and /think-scrutinize (defending an idea against skeptics).

Good-faith idea generator that produces candidate approaches for achieving a goal, parameterized by a specific brainstorming technique (first-principles, working-backwards, lateral, analogical, constraints-shift, worst-possible-idea, six-hats-green, SCAMPER). Returns ideas with brief rationale. Used in brainstorming proceedings alongside other brainstormers running different techniques in isolation.

Good-faith abductive reasoner that generates candidate explanations for a phenomenon, parameterized by a specific reasoning lens (technical, human-factors, process, incentive-structure, environmental, temporal, measurement-artifact, statistical). Returns candidate causes with predictions (what we'd expect to see if true), refuters (what would disprove it), and honest confidence. Used in diagnosis proceedings alongside other diagnosticians running different lenses in isolation.

Good-faith reflector that extracts learnings from a completed experience, parameterized by a specific reflection lens (what-worked-vs-got-lucky, what-didn't, what-surprised, system-rewards-vs-intent, decisions-that-aged, what-to-tell-past-self, patterns-that-recur). Returns structured learnings with explicit attribution to observation or recollection. Used in retrospective proceedings alongside other reflectors running different lenses in isolation.

Good-faith reframer that restates a problem through a specific reframing lens (problem-vs-symptom, scope-shift, stakeholder-shift, level-of-abstraction, time-horizon, inversion, category-shift, constraints-shift). Returns a reframed problem statement with an explicit diff from the original and an assessment of when the reframing applies. Used in reframing proceedings alongside other reframers running different lenses in isolation.

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.

Bug-fixing workflow that coordinates diagnosis, test-driven reproduction, root-cause analysis, and targeted fixes. Use when the user wants to fix a bug with thorough investigation and regression testing.

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.

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, review-doc, 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.

Autonomous technical lead. Takes commander's intent and drives a project to completion through an OODA loop over implementation, refactoring, review, and bug-hunting skills. Has broad authority — creates tickets, commits, invokes any skill — and only escalates via andon cord for irreversible actions, public releases, or genuinely blocking decisions. User acts as product owner; skill acts as tech lead.

Comprehensive refactoring workflow that combines tactical and architectural passes. Runs /refactor (tactical cleanup), /review-arch (architectural restructuring), then /refactor again (cleanup after restructuring). All user input gathered upfront; fully autonomous after that.

Autonomous iterative refactoring workflow. Scans for tactical code quality improvements (DRY, dead code, naming, complexity), implements through SMEs, verifies with QA, commits atomically, and loops until no improvements remain.

Accessibility audit. Dispatches an accessibility auditor to identify WCAG conformance gaps, prioritize by user impact, and recommend fixes. Advisory only — no changes made.

Interactive architectural review workflow. Analyzes codebase organization via noun analysis, produces a target blueprint, then collaborates with the user to decide what to implement. Changes are made through SMEs, verified with QA, and committed atomically.

Comprehensive pre-release review pipeline. Runs /review-health, /review-arch, /review-security, /review-perf, /review-a11y, /review-test, /review-doc, and /review-release in sequence. Thin orchestrator — each sub-skill keeps its normal interactive behavior. Auto-detects phases that do not apply and asks the user to confirm skipping them. Ends with a consolidated report.

Review all project documentation for correctness, completeness, and freshness. Spawns a doc-maintainer agent to audit and fix docs.

First-pass strategic-orientation review of a repository. Produces an evidence-cited map (not a grade) calibrated to a reference class, helping the user decide where to engage, where to tread carefully, and where to leave alone. Advisory only — no changes made.

Performance review. Detects project type and dispatches compute and/or web performance reviewers. Advisory only — no changes made.

Pre-release readiness review. Scans for debug artifacts, version mismatches, changelog gaps, git hygiene issues, breaking changes, and license compliance. Runs tests and build verification. Presents consolidated findings for human review before release.

White-box security audit. Blue-teamer evaluates defensive posture, then red-teamers attack informed by defensive gaps. Iterates when exploit chains are discovered. Heavy and thorough by design.

Comprehensive test suite review. Fills coverage gaps, identifies missing fuzz tests, and audits test quality — in that order.

Adversarial project planning workflow. Explores the problem space, drafts tickets in batches, then pits a planner against an implementer to find gaps. Creates well-specified, batch-tagged tickets upstream only after the implementer signs off.

Exploratory workflow for understanding problem spaces and drafting feature proposals, refactorings, or complex bug-fixes. Creates detailed tickets in your issue tracker without doing implementation work.

Mutation testing workflow. Systematically mutates source code to verify tests actually catch bugs. Multi-session with progress tracking.

Good-faith divergent brainstorming for achieving a goal. Validates assumptions, then spawns brainstormers running different techniques (first-principles, working-backwards, lateral, analogical, constraints-shift, etc.) in isolation, and synthesizes the pool into a report of standouts, reasonable ideas, and hybrid combinations. Produces feedback only — no code, no tickets, no artifacts.

Adversarial deliberation process for making decisions. Spawns advocate agents for each option who argue their cases before a judge (you) who renders a verdict.

Abductive reasoning about causes. Takes a phenomenon, separates observations from interpretations, then spawns diagnosticians applying different reasoning lenses (technical, human-factors, process, incentive-structure, environmental, temporal, measurement-artifact, statistical) in isolation. Orchestrator evaluates candidate causes for fit-against-evidence, calibrates confidence honestly, and reports leading candidate(s) with distinguishing evidence needed. Produces feedback only — no code, no tickets, no artifacts.

Retrospective learning from a completed experience. Takes a project, incident, decision that played out, or time period; gathers ground truth (observations) separately from recollections; spawns reflectors applying different lenses (what-worked-vs-got-lucky, what-didn't, what-surprised, system-rewards-vs-intent, decisions-that-aged, what-to-tell-past-self, patterns-that-recur) in isolation; synthesizes into updated mental models as first-class output. Produces feedback only — no code, no tickets, no artifacts.

Problem redefinition before problem solving. Takes a stated problem, extracts its premises, then spawns reframers applying different lenses (problem-vs-symptom, scope-shift, stakeholder-shift, level-of-abstraction, time-horizon, inversion, category-shift, constraints-shift) in isolation, and synthesizes the alternatives into a report with an orchestrator recommendation. Produces feedback only — no code, no tickets, no artifacts.

Good-faith adversarial scrutiny of an idea or plan. Spawns critical skeptics across relevant lenses, pairs them with an advocate defending the idea, and synthesizes the exchange into a report. Produces feedback only — no code, no tickets, no artifacts.