claude-dotfiles

Slash commands are user-invokable workflows that you trigger with `/command` syntax.

Generate changelog entries following Keep a Changelog format

Generate a well-structured pull request with summary and test plan

Cluster related instincts into skills, commands, or agents

Export instincts for sharing with teammates or backup

Import instincts from teammates or community collections

View learned instincts grouped by domain with confidence levels

Clean up project files, remove cruft, and organize codebase

Fix linting errors systematically across the codebase

Remove dead code, unused dependencies, and reduce complexity. Invokes the refactor-cleaner agent.

Safely update project dependencies with testing verification

Diagnose and fix build errors systematically. Invokes the build-resolver agent for type errors, dependency conflicts, and CI failures.

Comprehensive code review for quality, security, and maintainability. Invokes the code-reviewer agent.

Generate end-to-end tests for critical user flows

Security-focused code audit. Checks OWASP Top 10, secrets exposure, and vulnerability patterns. Invokes the security-reviewer agent.

Analyze and report test coverage with improvement suggestions

Save current verification state for resumption

Guide through a safe deployment process with verification

Evaluate code or implementation against specific criteria

Extract reusable patterns from the current session

Execute an approved multi-agent plan

Plan a complex task using multiple specialized agents

Coordinate multi-agent workflow for complex tasks

Create a detailed implementation plan before coding

Perform a thorough code review of recent changes

Manage and review session history and state

Create a new feature specification through structured interview

Show specification progress and next tasks

Update task status and add implementation notes

Start TDD workflow for a feature or bug fix. Enforces red-green-refactor cycle with the tdd-guide agent.

Run comprehensive pre-PR verification loop. Checks build, types, lint, tests, security, and coverage.

<!-- Tokens: ~400 | Lines: 55 | Compatibility: Claude Code 2.1+ -->

Software architecture specialist for system design, scalability, and technical decision-making. Use PROACTIVELY when planning new systems, evaluating trade-offs, or making structural decisions that affect multiple components.

Build and CI error diagnosis specialist. Systematically resolves build failures, type errors, dependency conflicts, and CI pipeline issues. Use when builds fail locally or in CI/CD pipelines.

Code quality and review specialist. Reviews code for correctness, security, performance, and maintainability. Use PROACTIVELY after writing or modifying code and before creating pull requests.

Database design and query optimization specialist. Reviews schemas, migrations, queries, and data access patterns. Use when working with PostgreSQL, Supabase, or any relational database code.

Documentation maintenance specialist. Keeps README, API docs, and inline documentation in sync with code changes. Use after significant code changes or when documentation drift is detected.

End-to-end testing specialist using Playwright. Generates and maintains E2E tests for critical user flows. Use when adding new features that need browser-level validation or when E2E tests are missing.

Go build and compilation error resolution specialist. Diagnoses and fixes build failures, type errors, and module dependency issues in Go projects. Use when Go build or test commands fail.

Go code review specialist. Reviews Go code for idioms, error handling, concurrency patterns, and ecosystem best practices. Use when reviewing Go projects or significant Go changes.

Implementation planning specialist. Analyzes requirements, identifies risks, and creates actionable step-by-step plans. Use PROACTIVELY when starting new features or making significant changes. WAITS for confirmation before coding.

Python code review specialist. Reviews Python code for idioms, type safety, performance, and ecosystem best practices. Use when reviewing Python projects or significant Python changes.

Dead code removal and refactoring specialist. Identifies unused code, redundant patterns, and opportunities for simplification. Use periodically or after feature completion to keep the codebase lean.

Security vulnerability detection and remediation specialist. Analyzes code for OWASP Top 10, injection attacks, authentication flaws, and secrets exposure. Use PROACTIVELY after writing code that handles user input, authentication, API endpoints, or sensitive data.

Specification interview specialist. Asks targeted questions across 8 categories to build comprehensive specs before implementation. Use when starting new features or planning complex changes that need clear requirements.

Test-driven development coach enforcing strict red-green-refactor methodology. Use PROACTIVELY when implementing new features, fixing bugs, or building critical business logic. Ensures tests are written before implementation.

API design and documentation assistant for REST and GraphQL APIs. Use when designing new endpoints, reviewing API structure, or creating API documentation. Follows industry best practices for consistent, intuitive API design.

Common backend development patterns for APIs, databases, caching, and service architecture. Language-agnostic principles with examples in Python, TypeScript, and Go.

Systematic code review for pull requests and code changes. Use when the user asks for a code review, PR review, or wants feedback on code quality. Provides structured feedback on correctness, security, performance, and maintainability.

Systematic debugging approach for identifying and fixing bugs. Use when the user reports a bug, error, or unexpected behavior. Guides through methodical investigation rather than guessing at solutions.

Comprehensive Go testing patterns. Covers table-driven tests, httptest, testcontainers, benchmarks, fuzzing, and race detection.

Reference template for creating project-specific CLAUDE.md files. Shows how to structure project guidelines with stack info, commands, directory structure, code standards, and gotchas sections for optimal Claude usage.

Comprehensive Python testing patterns using pytest. Covers fixtures, parametrize, async testing, mocking, property-based testing, and coverage analysis.

Safe refactoring patterns and techniques. Use when the user wants to improve code structure, reduce duplication, or make code more maintainable without changing behavior. Emphasizes incremental changes with test coverage.

Interview-first specification workflow for feature development. Guides through 8 question categories to build comprehensive specs before coding. Use when starting new features, planning complex changes, or establishing clear requirements before implementation.

Test-driven development workflow for implementing new features and fixing bugs. Use when the user mentions TDD, "write tests first", "red-green-refactor", or when implementing features that need comprehensive test coverage.

Pre-PR quality verification workflow. Runs build, type-check, lint, test, security scan, and coverage analysis in sequence. Stops on first failure and reports actionable fixes. Use before creating pull requests.

Generate API documentation from code or specifications. Use when documenting REST APIs, library APIs, or generating reference documentation. Supports OpenAPI, JSDoc, and markdown formats.

Generate and maintain changelogs following Keep a Changelog and Conventional Commits standards. Use when releasing versions, documenting changes, or updating project history.

Generate comprehensive README.md files for projects. Use when the user asks to create a README, document a project, or improve existing documentation. Creates well-structured READMEs following best practices.

Django 5.x best practices. Covers ORM optimization, class-based views, middleware, Django REST Framework, signals, and deployment patterns. Use when building Django applications or reviewing Django code.

Django security best practices. Covers CSRF, XSS, SQL injection prevention, authentication hardening, Content Security Policy, secrets management, and Django-specific security middleware configuration.

Test-driven development patterns for Django. Covers pytest-django setup, factory_boy factories, API testing with DRF, model testing, view testing, and integration test strategies with database transactions.

Pre-deployment verification workflow for Django projects. Covers migration checks, security audit, performance profiling, dependency scanning, deployment readiness, and production configuration validation.

FastAPI 0.110+ best practices. Covers dependency injection, async endpoints, Pydantic v2 validation, middleware, background tasks, and deployment patterns. Use when building FastAPI applications or reviewing FastAPI code.

Next.js 15+ App Router best practices. Covers server components, data fetching, caching, middleware, and deployment patterns. Use when building Next.js applications or reviewing Next.js code.

React 19+ best practices and patterns. Covers hooks, composition, server components, performance optimization, and state management. Use when building React components or reviewing React code.

Spring Boot 3.x best practices. Covers layered architecture, dependency injection, JPA/Hibernate patterns, REST controllers, configuration management, and production-ready features with Spring Actuator.

Spring Security 6.x best practices. Covers SecurityFilterChain, JWT auth, OAuth2, CORS, CSRF, method-level security, password encoding, and rate limiting for Spring Boot 3.x applications.

Test-driven development patterns for Spring Boot 3.x. Covers JUnit 5, MockMvc, Testcontainers, service mocking with Mockito, slice tests, integration tests, and test configuration management.

Git branching strategies and workflows. Use when setting up a project's branching model, discussing Git workflow, or deciding between trunk-based and Git Flow approaches.

Write clear, conventional commit messages. Use when the user asks to commit changes, needs help with commit messages, or when following Conventional Commits specification is required.

Create well-structured pull request descriptions. Use when the user wants to create a PR, needs help with PR descriptions, or is preparing changes for review. Generates clear titles and comprehensive descriptions.

Instinct-based learning system that observes development patterns via hooks and builds a knowledge base of reusable instincts with confidence scoring. Instincts evolve from observations into skills, commands, and agents.

Patterns for Claude Code to learn from project context and improve over time. Covers CLAUDE.md refinement, error pattern recognition, codebase conventions discovery, and feedback incorporation. Use to optimize Claude Code's effectiveness across sessions.

Structured evaluation framework for measuring code quality across multiple dimensions. Provides repeatable, scored assessments with evidence-based ratings.

Progressive context refinement pattern for subagents. Solves the problem of agents not knowing what context they need until they start working. Uses a 4-phase loop: DISPATCH, EVALUATE, REFINE, LOOP.

Context window optimization strategies for Claude Code. Covers token budgets, CLAUDE.md sizing, skill organization, tool selection, and techniques for maximizing productive output within context limits. Use when optimizing Claude Code configurations or managing large projects.

Go 1.22+ best practices, patterns, and idioms. Covers error handling, concurrency, interfaces, generics, and standard library patterns. Use when writing Go code or reviewing Go patterns.

Python 3.10+ best practices, patterns, and idioms. Covers type hints, async, dataclasses, protocols, and modern Python tooling. Use when writing Python code, reviewing Python patterns, or learning idiomatic Python.

Rust best practices, patterns, and idioms. Covers ownership, error handling with Result/Option, traits, lifetimes, and async Rust. Use when writing Rust code or reviewing Rust patterns.

TypeScript 5.x best practices, patterns, and idioms. Covers strict mode, branded types, discriminated unions, utility types, and Zod validation. Use when writing TypeScript or reviewing TS patterns.

Web accessibility review following WCAG guidelines. Use when auditing accessibility compliance, reviewing UI components, or ensuring inclusive design. Covers WCAG 2.1 Level AA requirements.

Performance analysis and optimization. Use when reviewing code for performance issues, identifying bottlenecks, or optimizing slow operations. Covers frontend, backend, and database performance.

Security review and vulnerability assessment. Use when reviewing code for security issues, auditing authentication/authorization, or checking for OWASP Top 10 vulnerabilities. Provides actionable security recommendations.

5 hooks across 2 events