superpowers-ecc

Start a brainstorming session to refine ideas into specs before writing code

Incrementally fix build and type errors with minimal, safe changes

Create or verify a checkpoint in your workflow for safe rollback points

Comprehensive security and quality review of uncommitted changes

Generate and run end-to-end tests with Playwright — create test journeys, run tests, capture artifacts

Cluster related instincts and evolve them into skills, commands, or agents

Execute an implementation plan with human checkpoints between task batches

Export instincts to a portable JSON file for sharing or backup

Import instincts from a JSON file into the local instinct library

Show all learned instincts grouped by domain with confidence scores

Extract reusable patterns from the session with a quality gate before saving as instincts

Analyze the current session and extract reusable patterns as instincts

Recommend the best model tier for the current task by complexity and budget

Multi-model collaborative execution — get prototype from plan, Claude refactors and implements, multi-model audit

Multi-model collaborative planning — context retrieval and dual-model analysis to generate step-by-step implementation plans

Alias for /write-plan — create a detailed implementation plan with bite-sized tasks

Run the quality pipeline on demand for a file or project scope

Safely identify and remove dead code with test verification at every step

Run security analysis on the current codebase using the security-reviewer agent

Manage Claude Code session history, aliases, and session metadata

Enforce test-driven development workflow — scaffold interfaces, generate tests FIRST, then implement minimal code to pass

Analyze test coverage, identify gaps, and generate missing tests to reach 80%+ coverage

Run comprehensive verification on current codebase state — build, types, lint, tests

Create a detailed implementation plan with bite-sized tasks

Software architecture specialist for system design, scalability, and technical decision-making. Use PROACTIVELY when planning new features, refactoring large systems, or making architectural decisions.

Build and TypeScript error resolution specialist. Use PROACTIVELY when build fails or type errors occur. Fixes build/type errors only with minimal diffs, no architectural edits. Focuses on getting the build green quickly.

Expert code review specialist. Proactively reviews code for quality, security, and maintainability. Use immediately after writing or modifying code. MUST BE USED for all code changes.

End-to-end testing specialist using Vercel Agent Browser (preferred) with Playwright fallback. Use PROACTIVELY for generating, maintaining, and running E2E tests. Manages test journeys, quarantines flaky tests, uploads artifacts (screenshots, videos, traces), and ensures critical user flows work.

Expert planning specialist for complex features and refactoring. Use PROACTIVELY when users request feature implementation, architectural changes, or complex refactoring. Automatically activated for planning tasks.

Dead code cleanup and consolidation specialist. Use PROACTIVELY for removing unused code, duplicates, and refactoring. Runs analysis tools (knip, depcheck, ts-prune) to identify dead code and safely removes it.

Security vulnerability detection and remediation specialist. Use PROACTIVELY after writing code that handles user input, authentication, API endpoints, or sensitive data. Flags secrets, SSRF, injection, unsafe crypto, and OWASP Top 10 vulnerabilities.

REST API design patterns including resource naming, status codes, pagination, filtering, error responses, versioning, and rate limiting for production APIs.

You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.

Use when extracting reusable patterns from sessions into instincts with confidence scoring for cross-session learning

Deployment workflows, CI/CD pipeline patterns, Docker containerization, health checks, rollback strategies, and production readiness checklists for web applications.

Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies

Playwright E2E testing patterns, Page Object Model, configuration, CI/CD integration, artifact management, and flaky test strategies.

Formal evaluation framework for Claude Code sessions implementing eval-driven development (EDD) principles

Use when you have a written implementation plan to execute in a separate session with review checkpoints

Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup

Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation

Use when completing tasks, implementing major features, or before merging to verify work meets requirements

Research-before-coding workflow. Search for existing tools, libraries, and patterns before writing custom code.

Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment/sensitive features. Provides comprehensive security checklist and patterns.

Suggests manual context compaction at logical workflow breakpoints to preserve context through task phases rather than losing it to arbitrary auto-compaction

Use when executing implementation plans with independent tasks in the current session

Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes

Use when implementing any feature or bugfix, before writing implementation code

Use when context is growing large, responses are slow, or you need to optimize token budget across system prompt, background processes, and model selection

Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification

Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions

Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always

A comprehensive verification system for Claude Code sessions.

Use when you have a spec or requirements for a multi-step task, before touching code

Use when creating new skills, editing existing skills, or verifying skills work before deployment

4 hooks across 3 events