general

Generate a context-aware commit message that matches this project's existing commit style. Reads git history and staged diff to produce a ready-to-run commit command.

Document a recently solved problem to compound team knowledge. Captures root cause, solution, and prevention strategies in docs/solutions/ while context is fresh.

Look up documentation for any topic or generate missing documentation. Searches local project docs (README, docs/, docstrings, JSDoc) first, then fetches external official documentation. Also generates documentation for undocumented code — use "generate: <target>" syntax.

Map the current repository's architecture, conventions, entry points, and patterns. Runs as a background sub-agent and returns a structured codebase report. Useful before implementing a feature in an unfamiliar codebase or when onboarding to a new project.

Generate unit tests, integration tests, and regression tests for existing or new code. Detects the project's test framework and conventions automatically. Runs as an isolated background agent. Invoke after implementation to ensure new code has coverage.

Execute a single bounded implementation task. Reads MULTI_AGENT_PLAN.md if present, or takes an inline task description. Stays within its assigned file scope and reports when done. Use after /plan for structured multi-task work.

Run a peer code review on recent changes as a background agent. Reviews for quality, best practices, performance, maintainability, and test coverage. Invoke after your primary implementation agent finishes.

Decompose a feature request into a structured implementation plan with clear task boundaries and file ownership. Writes MULTI_AGENT_PLAN.md for use by implementation agents. Run this before /implement on anything non-trivial.

Perform targeted, behavior-preserving refactoring within a defined scope. Runs as an isolated background agent. Updates callers, tests, and docs alongside the code change. Use a dash to separate scope from goal: /refactor src/auth/ — extract JWT into dedicated module.

Conduct deep research on any topic using specialized sub-agents for web, codebase, and documentation research

Quick all-in-one review of recent code changes covering quality, security, best practices, and performance. For deep specialized reviews use /peer-review or /security-review instead.

Run a security-focused review on recent changes as a background agent. Checks for OWASP Top 10, injection vulnerabilities, authentication flaws, secrets exposure, and common security anti-patterns.

Translate a feature request or issue into a structured spec with acceptance criteria, API contracts, and error cases. Output is ready for /plan. Use before /plan on any non-trivial feature to ensure requirements are clear before architecture begins.

Reviews or guides implementation of a 12-factor cloud-native application. Audits an existing codebase for 12-factor compliance, or provides concrete implementation guidance when building a new service. References patterns from well-structured microservices like gomods/athens.

Decomposes a feature request or problem into a structured implementation plan with clear task boundaries, file ownership, and acceptance criteria. Writes a MULTI_AGENT_PLAN.md that downstream implementation workers can consume without ambiguity. Read the codebase first, plan second.

Documentation lookup and synthesis skill. Searches local project documentation (README files, docs/, docstrings, JSDoc, type stubs), fetches official external documentation, and synthesizes answers. Also used for generating missing documentation. Loads project best-practices context automatically.

Analyzes staged changes and recent commit history to generate a well-formatted commit message that matches the project's existing commit style. Produces the commit command ready to run.

Manage git worktrees for AI agent workflows. Use when creating, listing, removing, or pruning worktrees, especially for ticket-based development where the agent needs to create isolated working directories for feature branches. Supports creating worktrees in .worktrees/ subdirectory, automatic branch creation from base branch (main), and cleanup of stale worktrees.

Focused implementation worker for a single bounded task. Reads from MULTI_AGENT_PLAN.md or an inline task spec and executes exactly one well-defined change within its assigned file scope. Stays in its lane — no scope creep, no touching files outside its assignment.

Senior engineer peer review skill. Reviews staged and recent code changes for quality, correctness, performance, maintainability, and test coverage. Designed to run as a background agent after primary implementation. Returns a structured report with findings categorized by severity.

Translates feature requests and issue descriptions into structured specs with acceptance criteria, API contracts, data model changes, and error cases. Output is consumed by architect-planner. Asks clarifying questions when requirements are ambiguous rather than guessing.

Performs targeted, bounded refactoring within a defined scope. Preserves observable behavior while improving structure, naming, or organization. Updates tests and inline documentation alongside code. Runs as an isolated background agent to avoid polluting main session context.

Maps a repository's architecture, conventions, patterns, and entry points. Use as a sub-agent when you need deep codebase understanding before making changes, debugging unfamiliar code, or onboarding to a new project. Returns a structured report covering structure, key files, patterns, and dependencies.

Orchestrates deep research across web, codebase, and documentation using parallel sub-agents. Returns a structured report with findings, sources, and recommendations.

Application security review skill. Checks code changes for OWASP Top 10 vulnerabilities, injection flaws, authentication issues, secrets exposure, and common security anti-patterns. Designed to run as a background agent after implementation on security-sensitive changes.

Implements features using strict TDD red-green-refactor cycle. Use when asked to implement using TDD, test-first development, red-green flow, write tests first, or when translating a spec or requirements precisely into working code without over-engineering.

Generates unit tests, integration tests, and regression tests for existing or newly written code. Detects the project's test framework and conventions before writing a single line. Runs as an isolated background agent so verbose test output does not pollute the main session context.

1 hook across 1 event