starter-pack

If you haven't read `.claude/docs/COMMIT_GUIDELINES.md` in this session, read it first.

First-principles debugging for complex issues

Delegate investigation and implementation to agents, keeping main context clean

Maintain documentation currency by analyzing recent changes and updating CLAUDE.md and .claude/docs/ files to reflect new patterns, lessons learned, and evolved practices.

Full workflow orchestration - analyze, implement, test, document, review

Use this agent to understand project structure, patterns, and conventions without loading extensive code into your main context. This agent should be used when you need to understand how the codebase is organized, find patterns across files, or locate implementations. Examples: <example>Context: User asks about implementing a new feature. user: 'I need to add a new payment processing module to my application' assistant: 'Let me use the codebase-analyzer agent to understand your current architecture and identify the best place to add this module.' <commentary>Since we need to understand the overall project structure and existing patterns before implementing, use the codebase-analyzer to explore without polluting main context.</commentary></example> <example>Context: User wants to follow existing patterns. user: 'How are services typically structured in this project?' assistant: 'I'll use the codebase-analyzer agent to identify the service patterns used throughout your codebase.' <commentary>Instead of loading multiple service files into context, the analyzer can identify patterns efficiently.</commentary></example> <example>Context: User needs to find where something is implemented. user: 'Where is the authentication logic handled in this project?' assistant: 'Let me use the codebase-analyzer agent to map out the authentication flow and locate all relevant files.' <commentary>The analyzer can trace through the codebase to find all auth-related code without loading everything.</commentary></example>

Use this agent to explore and understand documentation without loading it all into your context. This agent should be used when you need to understand APIs, libraries, frameworks, or project-specific documentation. Examples: <example>Context: User asks about using a specific library feature. user: 'How do I use the advanced caching features of this Redis client library?' assistant: 'Let me use the docs-explorer agent to research the Redis client library documentation for advanced caching features.' <commentary>Instead of loading entire library docs, the explorer agent can find and summarize relevant sections.</commentary></example> <example>Context: User needs to understand project conventions. user: 'What are the API design guidelines for this project?' assistant: 'I'll use the docs-explorer agent to review your API documentation and design guidelines.' <commentary>The agent can analyze project docs and extract key guidelines without cluttering main context.</commentary></example> <example>Context: User wants to understand configuration options. user: 'What environment variables does this application support?' assistant: 'Let me use the docs-explorer agent to scan the configuration documentation and README files.' <commentary>Documentation agent can comprehensively search all docs for configuration information.</commentary></example>

Use this agent to analyze and update project documentation based on code changes. This agent should be invoked when significant changes are made to architecture, patterns, or workflows. Examples: <example>Context: After implementing a new architectural pattern. user: 'We just added a new event-driven messaging system to the architecture' assistant: 'Let me use the docs-maintainer agent to update our architecture documentation with this new pattern.' <commentary>Since a new architectural pattern was introduced, the docs-maintainer should update relevant documentation.</commentary></example> <example>Context: After discovering and fixing a common bug pattern. user: 'We found that our async error handling was inconsistent across services' assistant: 'I'll use the docs-maintainer agent to document this pattern in our debugging guide.' <commentary>Learning from bugs should be captured in documentation for future reference.</commentary></example> <example>Context: After establishing new conventions. user: 'We decided to use factory patterns for all service instantiation' assistant: 'Let me use the docs-maintainer agent to update our guidelines with this new convention.' <commentary>New conventions should be documented to ensure consistency across the team.</commentary></example>

Use this agent to investigate complex issues, research implementations, or track down root causes while keeping the main context clean. The investigator does deep research but returns only essential findings. Examples: <example>Context: Debugging an intermittent error. user: 'Users are getting random 401 errors but only sometimes' assistant: 'Let me use the investigator agent to track down the root cause of these intermittent 401 errors.' <commentary>The investigator will follow the authentication flow, check token handling, examine race conditions, but return only the root cause and fix.</commentary></example> <example>Context: Researching API usage. user: 'How do we integrate with Stripe for subscription billing?' assistant: 'I'll use the investigator agent to research the Stripe API integration patterns for subscriptions.' <commentary>The investigator will read extensive API docs, check examples, find best practices, but return only the essential implementation approach.</commentary></example> <example>Context: Performance investigation. user: 'The checkout process has become really slow recently' assistant: 'Let me use the investigator agent to find what's causing the checkout performance degradation.' <commentary>The investigator will profile the code, trace database queries, check network calls, but return only the bottleneck and solution.</commentary></example>

Use this agent when you need expert-level technical guidance on complex software engineering challenges. Specifically invoke this agent for: architectural design reviews and planning, debugging complex issues that standard approaches haven't resolved, performance optimization and bottleneck analysis, security vulnerability assessments, database schema design and optimization, API design and REST/GraphQL architecture decisions, code quality reviews for critical systems, refactoring strategy for legacy codebases, technology stack selection and migration planning, or any scenario requiring deep technical expertise beyond routine implementation. Examples: <example>Context: User needs help with a complex performance issue in their application. user: "Our application is experiencing severe performance degradation when processing large datasets. We've tried basic optimizations but need expert guidance." assistant: "I'll use the senior-dev-consultant agent to analyze this performance issue and provide expert recommendations." <commentary>The user is facing a complex performance problem that requires senior-level expertise to diagnose and resolve.</commentary></example> <example>Context: User is planning a major architectural change. user: "We're considering migrating from a monolithic architecture to microservices. What are the key considerations?" assistant: "Let me engage the senior-dev-consultant agent to provide strategic guidance on this architectural transition." <commentary>This is a major architectural decision that requires senior-level expertise to evaluate trade-offs and implementation strategies.</commentary></example> <example>Context: User has a subtle bug that's hard to track down. user: "We have an intermittent race condition in our async code that only happens in production under load." assistant: "I'll use the senior-dev-consultant agent to help diagnose this complex concurrency issue." <commentary>Race conditions and production-only bugs require deep debugging expertise and systematic analysis.</commentary></example> <example>Context: User needs help with database optimization. user: "Our database queries are taking too long and causing timeouts. We need to optimize our schema and query patterns." assistant: "I'll use the senior-dev-consultant agent to analyze your database performance and provide optimization strategies." <commentary>Database optimization requires deep understanding of indexing strategies, query execution plans, and schema design.</commentary></example> <example>Context: User wants to improve their CI/CD pipeline. user: "Our deployment process is slow and error-prone. How can we improve our CI/CD pipeline?" assistant: "Let me use the senior-dev-consultant agent to evaluate your current pipeline and recommend improvements." <commentary>CI/CD optimization requires expertise in build systems, testing strategies, and deployment architectures.</commentary></example>