core

Run comprehensive agent-native architecture review with scored principles

Create engaging changelogs for recent merges to main branch

Create or edit Claude Code skills with expert guidance on structure and best practices

Enhance a plan with parallel research agents for each section to add depth, best practices, and implementation details

Remove AI-generated code slop from a branch. Use when cleaning up AI-generated code, removing unnecessary comments, defensive checks, or type casts. Checks diff against main and fixes style inconsistencies.

Create a new custom slash command following conventions and best practices

Complete git workflow automation - commit, push, create PR, wait for CI, fetch results, merge

Fix incorrect SKILL.md files when a skill has wrong instructions or outdated API references

Have multiple specialized agents review a plan in parallel

Resolve all TODO comments using parallel processing

Resolve all PR comments using parallel processing

Resolve all pending CLI todos using parallel processing

Triage and categorize findings for the CLI todo system

Explore requirements and approaches through collaborative dialogue before planning implementation

Document a recently solved problem to compound your team's knowledge

Transform feature descriptions into well-structured project plans following conventions

Perform exhaustive code reviews using multi-agent analysis, ultra-thinking, and worktrees

Execute work plans efficiently while maintaining quality and finishing features

Use this agent when you need to explore API design decisions before implementation. This includes choosing between REST/GraphQL/gRPC, designing endpoint structures, versioning strategies, pagination approaches, error handling patterns, and authentication integration. Best used early in feature design when API surface area is being defined. <example>Context: The user is designing a new API for their service. user: "I need to build an API for our order management system" assistant: "I'll use the api-design-brainstormer agent to explore the design options" <commentary>Since the user is designing a new API, use this agent to explore trade-offs before committing to an approach.</commentary></example><example>Context: The user is considering changing their API approach. user: "Should we migrate from REST to GraphQL for our mobile app?" assistant: "Let me analyze this with the api-design-brainstormer agent to weigh the trade-offs" <commentary>API paradigm changes have significant implications that warrant structured exploration.</commentary></example>

Use this agent when you need to explore data modeling decisions before implementation. This includes schema design approaches, relationship modeling, primary key strategies, indexing considerations, soft delete patterns, audit trails, multi-tenancy, and migration strategies. Best used when designing new tables/collections or restructuring existing data. <example>Context: The user is designing a new feature that requires data modeling. user: "I need to add a comments system to our blog" assistant: "I'll use the data-model-brainstormer agent to explore the data model options" <commentary>Since the user needs to model new data, use this agent to explore trade-offs in schema design.</commentary></example><example>Context: The user is considering a data model change. user: "Should we normalize our user preferences or keep them as JSON?" assistant: "Let me analyze this with the data-model-brainstormer agent to weigh the trade-offs" <commentary>Normalization decisions have significant implications that warrant structured exploration.</commentary></example>

Challenge emerging approaches by actively seeking flaws, risks, and overlooked alternatives. Use during brainstorming to stress-test ideas before committing. Invoked with the current proposed direction to find weaknesses.

Get alternative perspectives on architectural decisions and feature planning from Google Gemini. Use when you want a second opinion from a different LLM on design approaches, trade-offs, or implementation strategies.

Use this agent when you need to explore security design decisions before implementation. This includes authentication methods, authorization patterns, data protection approaches, input validation, rate limiting, secret management, audit logging, and threat modeling. Best used when designing security architecture or evaluating security trade-offs. <example>Context: The user is designing authentication for a new service. user: "I need to add authentication to our API" assistant: "I'll use the security-brainstormer agent to explore the authentication options" <commentary>Since the user is designing authentication, use this agent to explore security trade-offs before committing.</commentary></example><example>Context: The user is evaluating authorization approaches. user: "Should we use RBAC or ABAC for our permissions system?" assistant: "Let me analyze this with the security-brainstormer agent to weigh the trade-offs" <commentary>Authorization pattern changes have significant security implications that warrant structured exploration.</commentary></example>

Use this agent when you need to explore state management decisions before implementation. This includes local vs global state boundaries, client-side caching, optimistic updates, state persistence, sync vs async handling, real-time synchronization, undo/redo patterns, and state migration between versions. Best used when designing complex UI state or distributed state systems. <example>Context: The user is designing state management for a new feature. user: "I'm building a collaborative document editor and need to handle state" assistant: "I'll use the state-management-brainstormer agent to explore the options" <commentary>Since the user is designing state for a collaborative feature, use this agent to explore synchronization and persistence trade-offs.</commentary></example><example>Context: The user is reconsidering their state approach. user: "Our Redux store is getting complex, should we split it up?" assistant: "Let me analyze this with the state-management-brainstormer agent to weigh the options" <commentary>State architecture changes have cascading effects that warrant structured exploration.</commentary></example>

Researches and synthesizes external best practices, documentation, and examples for any technology or framework. Use when you need industry standards, community conventions, or implementation guidance.

Use this agent when you need to gather comprehensive documentation and best practices for frameworks, libraries, or dependencies in your project. This includes fetching official documentation, exploring source code, identifying version-specific constraints, and understanding implementation patterns. <example>Context: The user needs to understand how to properly implement a new feature using a specific library. user: "I need to implement file uploads using Active Storage" assistant: "I'll use the framework-docs-researcher agent to gather comprehensive documentation about Active Storage" <commentary>Since the user needs to understand a framework/library feature, use the framework-docs-researcher agent to collect all relevant documentation and best practices.</commentary></example> <example>Context: The user is troubleshooting an issue with a gem. user: "Why is the turbo-rails gem not working as expected?" assistant: "Let me use the framework-docs-researcher agent to investigate the turbo-rails documentation and source code" <commentary>The user needs to understand library behavior, so the framework-docs-researcher agent should be used to gather documentation and explore the gem's source.</commentary></example>

Performs archaeological analysis of git history to trace code evolution, identify contributors, and understand why code patterns exist. Use when you need historical context for code changes.

Searches docs/solutions/ for relevant past solutions by frontmatter metadata. Use before implementing features or fixing problems to surface institutional knowledge and prevent repeated mistakes.

Conducts thorough research on repository structure, documentation, conventions, and implementation patterns. Use when onboarding to a new codebase or understanding project conventions.

Use this agent when reviewing code to ensure features are agent-native - that any action a user can take, an agent can also take, and anything a user can see, an agent can see. This enforces the principle that agents should have parity with users in capability and context. <example>Context: The user added a new feature to their application. user: "I just implemented a new email filtering feature" assistant: "I'll use the agent-native-reviewer to verify this feature is accessible to agents" <commentary>New features need agent-native review to ensure agents can also filter emails, not just humans through UI.</commentary></example><example>Context: The user created a new UI workflow. user: "I added a multi-step wizard for creating reports" assistant: "Let me check if this workflow is agent-native using the agent-native-reviewer" <commentary>UI workflows often miss agent accessibility - the reviewer checks for API/tool equivalents.</commentary></example>

Use this agent when you need to analyze code changes from an architectural perspective, evaluate system design decisions, or ensure that modifications align with established architectural patterns. This includes reviewing pull requests for architectural compliance, assessing the impact of new features on system structure, or validating that changes maintain proper component boundaries and design principles. <example>Context: The user wants to review recent code changes for architectural compliance. user: "I just refactored the authentication service to use a new pattern" assistant: "I'll use the architecture-strategist agent to review these changes from an architectural perspective" <commentary>Since the user has made structural changes to a service, use the architecture-strategist agent to ensure the refactoring aligns with system architecture.</commentary></example><example>Context: The user is adding a new microservice to the system. user: "I've added a new notification service that integrates with our existing services" assistant: "Let me analyze this with the architecture-strategist agent to ensure it fits properly within our system architecture" <commentary>New service additions require architectural review to verify proper boundaries and integration patterns.</commentary></example>

Use this agent to detect atomic code smells in individual functions and classes. Checks 17 categories including naming precision, function composition, boolean complexity, missing domain modeling, type-based branching, control flow, state/flags, dependency injection, type design, error handling, and more. Best used during code review or before merging changes.

Use this agent when you need a final review pass to ensure code changes are as simple and minimal as possible. This agent should be invoked after implementation is complete but before finalizing changes, to identify opportunities for simplification, remove unnecessary complexity, and ensure adherence to YAGNI principles. Examples: <example>Context: The user has just implemented a new feature and wants to ensure it's as simple as possible. user: "I've finished implementing the user authentication system" assistant: "Great! Let me review the implementation for simplicity and minimalism using the code-simplicity-reviewer agent" <commentary>Since implementation is complete, use the code-simplicity-reviewer agent to identify simplification opportunities.</commentary></example> <example>Context: The user has written complex business logic and wants to simplify it. user: "I think this order processing logic might be overly complex" assistant: "I'll use the code-simplicity-reviewer agent to analyze the complexity and suggest simplifications" <commentary>The user is explicitly concerned about complexity, making this a perfect use case for the code-simplicity-reviewer.</commentary></example>

Use this agent to detect repetition, consistency, and dead code issues across files. Analyzes duplication, naming consistency, validation scattering, business rule scattering, condition patterns, error handling styles, interface consistency, and zombie code. Works at both file-scope (2+ occurrences) and codebase-scope (3+ files).

Use this agent when reviewing PRs that touch database migrations, data backfills, or any code that transforms production data. This agent validates ID mappings against production reality, checks for swapped values, verifies rollback safety, and ensures data integrity during schema changes. Essential for any migration that involves ID mappings, column renames, or data transformations. <example>Context: The user has a PR with database migrations that involve ID mappings. user: "Review this PR that migrates from action_id to action_module_name" assistant: "I'll use the data-migration-expert agent to validate the ID mappings and migration safety" <commentary>Since the PR involves ID mappings and data migration, use the data-migration-expert to verify the mappings match production and check for swapped values.</commentary></example> <example>Context: The user has a migration that transforms enum values. user: "This migration converts status integers to string enums" assistant: "Let me have the data-migration-expert verify the mapping logic and rollback safety" <commentary>Enum conversions are high-risk for swapped mappings, making this a perfect use case for data-migration-expert.</commentary></example>

Use this agent for codebase-wide architectural analysis. Detects issues ONLY visible through full codebase view including module structure problems (circular deps, layer violations), architecture issues (wrong boundaries, bottlenecks), cross-file comprehension problems, abstraction opportunities, and feature flag sprawl. Requires periodic review or comprehensive codebase exploration.

Use this agent when you need to analyze code for design patterns, anti-patterns, naming conventions, and code duplication. This agent excels at identifying architectural patterns, detecting code smells, and ensuring consistency across the codebase. <example>Context: The user wants to analyze their codebase for patterns and potential issues. user: "Can you check our codebase for design patterns and anti-patterns?" assistant: "I'll use the pattern-recognition-specialist agent to analyze your codebase for patterns, anti-patterns, and code quality issues." <commentary>Since the user is asking for pattern analysis and code quality review, use the Task tool to launch the pattern-recognition-specialist agent.</commentary></example><example>Context: After implementing a new feature, the user wants to ensure it follows established patterns. user: "I just added a new service layer. Can we check if it follows our existing patterns?" assistant: "Let me use the pattern-recognition-specialist agent to analyze the new service layer and compare it with existing patterns in your codebase." <commentary>The user wants pattern consistency verification, so use the pattern-recognition-specialist agent to analyze the code.</commentary></example>

Use this agent when you need to analyze code for performance issues, optimize algorithms, identify bottlenecks, or ensure scalability. This includes reviewing database queries, memory usage, caching strategies, and overall system performance. The agent should be invoked after implementing features or when performance concerns arise. <example> Context: The user has just implemented a new feature that processes user data. user: "I've implemented the user analytics feature. Can you check if it will scale?" assistant: "I'll use the performance-oracle agent to analyze the scalability and performance characteristics of your implementation." <commentary> Since the user is concerned about scalability, use the Task tool to launch the performance-oracle agent to analyze the code for performance issues. </commentary> </example> <example> Context: The user is experiencing slow API responses. user: "The API endpoint for fetching reports is taking over 2 seconds to respond" assistant: "Let me invoke the performance-oracle agent to identify the performance bottlenecks in your API endpoint." <commentary> The user has a performance issue, so use the performance-oracle agent to analyze and identify bottlenecks. </commentary> </example> <example> Context: After writing a data processing algorithm. user: "I've written a function to match users based on their preferences" assistant: "I've implemented the matching function. Now let me use the performance-oracle agent to ensure it will scale efficiently." <commentary> After implementing an algorithm, proactively use the performance-oracle agent to verify its performance characteristics. </commentary> </example>

Use this agent when you need to perform security audits, vulnerability assessments, or security reviews of code. This includes checking for common security vulnerabilities, validating input handling, reviewing authentication/authorization implementations, scanning for hardcoded secrets, and ensuring OWASP compliance. <example>Context: The user wants to ensure their newly implemented API endpoints are secure before deployment. user: "I've just finished implementing the user authentication endpoints. Can you check them for security issues?" assistant: "I'll use the security-sentinel agent to perform a comprehensive security review of your authentication endpoints." <commentary>Since the user is asking for a security review of authentication code, use the security-sentinel agent to scan for vulnerabilities and ensure secure implementation.</commentary></example> <example>Context: The user is concerned about potential SQL injection vulnerabilities in their database queries. user: "I'm worried about SQL injection in our search functionality. Can you review it?" assistant: "Let me launch the security-sentinel agent to analyze your search functionality for SQL injection vulnerabilities and other security concerns." <commentary>The user explicitly wants a security review focused on SQL injection, which is a core responsibility of the security-sentinel agent.</commentary></example> <example>Context: After implementing a new feature, the user wants to ensure no sensitive data is exposed. user: "I've added the payment processing module. Please check if any sensitive data might be exposed." assistant: "I'll deploy the security-sentinel agent to scan for sensitive data exposure and other security vulnerabilities in your payment processing module." <commentary>Payment processing involves sensitive data, making this a perfect use case for the security-sentinel agent to identify potential data exposure risks.</commentary></example>

Detect AI-generated code slop in PRs. Identifies unnecessary comments, defensive over-engineering, type workarounds, inline imports, and style inconsistencies that are hallmarks of AI-generated code. Use during code review to catch slop before it's merged.

Use this agent when you receive a bug report or issue description and need to verify whether the reported behavior is actually a bug. This agent will attempt to reproduce the issue systematically, validate the steps to reproduce, and confirm whether the behavior deviates from expected functionality. <example> Context: The user has reported a potential bug in the application. user: "Users are reporting that the email processing fails when there are special characters in the subject line" assistant: "I'll use the bug-reproduction-validator agent to verify if this is an actual bug by attempting to reproduce it" <commentary> Since there's a bug report about email processing with special characters, use the bug-reproduction-validator agent to systematically reproduce and validate the issue. </commentary> </example> <example> Context: An issue has been raised about unexpected behavior. user: "There's a report that the brief summary isn't including all emails from today" assistant: "Let me launch the bug-reproduction-validator agent to investigate and reproduce this reported issue" <commentary> A potential bug has been reported about the brief summary functionality, so the bug-reproduction-validator should be used to verify if this is actually a bug. </commentary> </example>

Use this agent for structured multi-step reasoning on open-ended analytical questions where the answer structure is unknown. Handles taxonomy design, conceptual analysis, trade-off exploration, and definitional questions. Best for questions like "What's the correct way to classify X?", "What makes a good Y?", "How should I balance A versus B?"

Use this agent when you need to address comments on pull requests or code reviews by making the requested changes and reporting back on the resolution. This agent handles the full workflow of understanding the comment, implementing the fix, and providing a clear summary of what was done. <example>Context: A reviewer has left a comment on a pull request asking for a specific change to be made.user: "The reviewer commented that we should add error handling to the payment processing method"assistant: "I'll use the pr-comment-resolver agent to address this comment by implementing the error handling and reporting back"<commentary>Since there's a PR comment that needs to be addressed with code changes, use the pr-comment-resolver agent to handle the implementation and resolution.</commentary></example><example>Context: Multiple code review comments need to be addressed systematically.user: "Can you fix the issues mentioned in the code review? They want better variable names and to extract the validation logic"assistant: "Let me use the pr-comment-resolver agent to address these review comments one by one"<commentary>The user wants to resolve code review feedback, so the pr-comment-resolver agent should handle making the changes and reporting on each resolution.</commentary></example>

Use this agent to identify the root cause of a problem. This agent determines WHY something is happening, NOT how to fix it. Best used when investigating bugs, unexpected behavior, or complex issues before proposing solutions. The agent generates hypotheses, investigates evidence, and outputs a validated root cause statement.

Use this agent for comprehensive refactoring analysis across 11 dimensions. Detects technical debt that LLMs miss - duplication across files, god functions growing, inconsistent validation logic. Explores architecture, modules, abstraction, types, errors, conditionals, naming, extraction, testability, modernization, and readability. Outputs prioritized recommendations with evidence.

Use this agent when you have a defined problem and need to explore solution space. Generates diverse solutions from 7 different reasoning perspectives (minimal, structural, stateless, domain, removal, first principles, upstream) to avoid anchoring on the first idea. Best used after problem-analysis when multiple approaches could work.

Use this agent when you have a specification, plan, feature description, or technical document that needs user flow analysis and gap identification. This agent should be used proactively when: <example> Context: The user has just finished drafting a specification for OAuth implementation. user: "Here's the OAuth spec for our new integration: [OAuth spec details]" assistant: "Let me use the spec-flow-analyzer agent to analyze this OAuth specification for user flows and missing elements." <commentary> Since the user has provided a specification document, use the Task tool to launch the spec-flow-analyzer agent to identify all user flows, edge cases, and missing clarifications. </commentary> </example> <example> Context: The user is planning a new social sharing feature. user: "I'm thinking we should add social sharing to posts. Users can share to Twitter, Facebook, and LinkedIn." assistant: "This sounds like a feature specification that would benefit from flow analysis. Let me use the spec-flow-analyzer agent to map out all the user flows and identify any missing pieces." <commentary> The user is describing a new feature. Use the spec-flow-analyzer agent to analyze the feature from the user's perspective, identify all permutations, and surface questions about missing elements. </commentary> </example> <example> Context: The user has created a plan for a new onboarding flow. user: "Can you review this onboarding plan and make sure we haven't missed anything?" assistant: "I'll use the spec-flow-analyzer agent to thoroughly analyze this onboarding plan from the user's perspective." <commentary> The user is explicitly asking for review of a plan. Use the spec-flow-analyzer agent to identify all user flows, edge cases, and gaps in the specification. </commentary> </example> Call this agent when: - A user presents a feature specification, plan, or requirements document - A user asks to review or validate a design or implementation plan - A user describes a new feature or integration that needs flow analysis - After initial planning sessions to validate completeness - Before implementation begins on complex user-facing features - When stakeholders need clarity on user journeys and edge cases

This skill should be used when building AI agents using prompt-native architecture where features are defined in prompts, not code. Use it when creating autonomous agents, designing MCP servers, implementing self-modifying systems, or adopting the "trust the agent's intelligence" philosophy.

This skill should be used before implementing features, building components, or making changes. It guides exploring user intent, approaches, and design decisions before planning. Triggers on "let's brainstorm", "help me think through", "what should we build", "explore approaches", ambiguous feature requests, or when the user's request has multiple valid interpretations that need clarification.

Capture solved problems as categorized documentation with YAML frontmatter for fast lookup

This skill provides expert guidance for creating, writing, building, and refining Claude Code Skills. It should be used when working with SKILL.md files, authoring new skills, improving existing skills, or understanding skill structure and best practices.

Create Claude Code hooks with proper patterns, security best practices, and configuration. Use this skill when building PreToolUse, PostToolUse, SessionStart, or other hook types for plugins.

Create new Claude Code rules with proper structure and best practices. Use this skill when developing custom rules for coding standards, conventions, or guidelines that Claude should follow.

Set up fast file suggestions for Claude Code using ripgrep, jq, and fzf. Use this skill when users want to improve file autocomplete performance or add custom file suggestion behavior.

This skill should be used when managing the file-based todo tracking system in the todos/ directory. It provides workflows for creating todos, managing status and dependencies, conducting triage, and integrating with slash commands and code review processes.

Complete git workflow automation - commit, push, create PR, wait for CI, fetch results, merge. Use when you need to ship changes with proper commits and PR descriptions.

This skill manages Git worktrees for isolated parallel development. It handles creating, listing, switching, and cleaning up worktrees with a simple interactive interface, following KISS principles.

This skill should be used when you need to import tasks from another Claude Code session's TaskList into your current session, enabling coordination across sessions without restarting.

This skill manages CLAUDE.md and AGENTS.md files that configure AI coding agent behavior. Use when creating, auditing, refactoring, or syncing agent instruction files.

Set up Claude Code rules in a project by symlinking from the rbw-claude-code templates. Use this skill when users want to add Python coding standards, anti-slop rules, or other shared rules to their projects.

Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.

This skill documents conventions for using the built-in TaskList tools (TaskCreate, TaskUpdate, TaskList, TaskGet) for tracking execution progress within and across Claude Code sessions.

1 hook across 1 event