Analyze code for accessibility compliance and create an a11y improvement plan

Analyze API design and create an API improvement plan

Analyze architectural patterns and create an architecture improvement plan

Display the comprehensive guide to Bad Dave's Robot Army capabilities

Approach code with fresh curiosity and learning mindset

Analyze build systems and CI/CD pipelines to identify optimization opportunities

Analyze AWS cloud architecture and create a cloud optimization plan

Comprehensive code evolution analysis through git history, PRs, and collaborative development patterns

Quick analysis of code evolution and key patterns

Generate a comprehensive, beginner-friendly overview of the entire codebase

Analyze concurrent programming patterns and create a concurrency improvement plan

Analyze configuration management and environment settings to identify security risks and improvement opportunities

Create a comprehensive product requirements document for features within the current project/codebase

Analyze database design and create a database optimization plan

Break down a large GitHub issue into smaller, manageable sub-issues with appropriate linkages and dependencies.

Analyze deployment processes and create a deployment improvement plan

Analyze documentation needs and create a documentation improvement plan

Analyze whether code fits with established codebase patterns and conventions

**Name:** exception-review

Get a personalized explanation of code, architecture, or concepts in the codebase

Automatically implement a GitHub issue by pulling it down, solving it with the appropriate specialist agent, and creating a PR with the solution.

Using the development manager subagent, create a comprehensive implementation plan from a Product Requirements Document (PRD) for features within the current project/codebase.

Analyze code for i18n readiness and create a localization plan

Create a personalized learning path for mastering the codebase or specific technologies

Analyze logging and observability practices and create an improvement plan

Analyze code for modernization opportunities and create an update plan

Analyze performance bottlenecks and create an optimization plan

Process technical team feedback on an implementation plan and create an updated version incorporating their input

Process stakeholder feedback on a PRD and create an updated version incorporating their input

Analyze quality assurance practices and create a quality improvement plan

Analyze code quality and create a refactoring improvement plan

Analyze security vulnerabilities and create a security improvement plan

Convert a review plan into GitHub issues for tracking

Analyze test coverage and create a testing improvement plan

Analyze developer tooling and workflow to create an improvement plan

Check plan completion status by verifying issues, PRs, and actual implementation

Analyze the blast radius of a potential change to help understand system dependencies and impact

Investigate why code was built a certain way instead of obvious alternatives, combining code archaeology with architectural analysis

Accessibility expert that ensures applications are usable by everyone, implementing WCAG guidelines and assistive technology support. Use PROACTIVELY when building inclusive applications.

API design expert that creates intuitive, consistent, and scalable interfaces for services. Use PROACTIVELY when designing REST, GraphQL, or gRPC APIs.

Reviews code changes for architectural consistency and patterns. Use PROACTIVELY after any structural changes, new services, or API modifications. Ensures SOLID principles, proper layering, and maintainability.

Build system and CI/CD pipeline expert that optimizes compilation, packaging, and deployment processes. Use PROACTIVELY when setting up builds, CI/CD, or fixing build issues.

AWS cloud architecture expert that designs and implements scalable, resilient cloud-native solutions. Use PROACTIVELY when building cloud applications or migrating to AWS.

Documentation specialist that creates comprehensive, clear, and maintainable documentation for codebases. Use PROACTIVELY after implementing features or when documentation is needed.

Code evolution and history analysis expert that tracks how code has changed over time, who changed it, and patterns in collaborative development. Use when investigating code evolution, understanding change patterns, or analyzing development history.

Legacy code transformation expert that updates outdated codebases to use modern patterns, libraries, and language features. Use PROACTIVELY when planning upgrade roadmaps or upgrading legacy code.

Expert code review specialist. Proactively reviews code for quality, security, and maintainability. Use immediately after writing or modifying code.

Concurrent programming expert that implements thread-safe code, async patterns, and distributed systems. Use PROACTIVELY when dealing with parallelism, race conditions, or scaling challenges.

Configuration and environment management expert that handles application settings, secrets, and deployment configurations. Use PROACTIVELY when managing configs across environments.

Database architecture expert that designs efficient schemas, optimizes queries, and ensures data integrity. Use PROACTIVELY when designing data models or solving database performance issues.

Expert troubleshooter that systematically identifies, isolates, and resolves bugs in code. Use PROACTIVELY when encountering errors, crashes, or unexpected behavior.

Deployment automation expert that implements zero-downtime releases, rollback strategies, and continuous delivery pipelines. Use PROACTIVELY when setting up deployment processes or release management.

Development management expert that transforms product requirements into comprehensive technical implementation plans with detailed architecture, resource allocation, and risk assessment. Use when creating implementation roadmaps from PRDs.

Error handling and resilience expert that implements robust exception management and recovery strategies. Use when implementing error handling systems.

I18n expert that implements multi-language support, handles localization, and ensures applications work seamlessly across different languages and regions. Use PROACTIVELY when building global applications.

Learning-focused development assistant that approaches code with curiosity and asks thoughtful questions

Logging and observability expert that implements comprehensive logging strategies for debugging, monitoring, and auditing. Use PROACTIVELY when setting up logging systems.

Teaching and knowledge transfer expert that provides customized learning experiences about the codebase and its technologies. Use PROACTIVELY when explaining concepts or answering technical questions.

Performance tuning expert that identifies and eliminates bottlenecks to maximize application speed and efficiency. Use PROACTIVELY when facing performance issues.

Product-focused development strategist that bridges technical implementation with business requirements and user needs. Use when planning features or defining requirements.

Quality assurance expert that implements comprehensive testing strategies, defect prevention, and quality metrics. Use PROACTIVELY when establishing quality processes or improving software reliability.

Code improvement specialist that restructures code for better readability, maintainability, and design without changing functionality. Use PROACTIVELY when code becomes complex or hard to maintain.

Security expert that identifies vulnerabilities, implements secure coding practices, and ensures applications are protected against common threats. Use PROACTIVELY when implementing security features or auditing code.

Test automation expert that designs and implements comprehensive test suites for maximum code coverage and reliability. Use PROACTIVELY after implementing new features or fixing bugs.

Developer Experience specialist. Improves tooling, setup, and workflows. Use PROACTIVELY when setting up new projects, after team feedback, or when development friction is noticed.