basic-workflow

⚡ Answer technical and architectural questions.

⚡⚡⚡⚡⚡ Bootstrap a new project step by step

⚡⚡⚡⚡ Bootstrap a new project automatically

⚡⚡⚡ Quickly bootstrap a new project automatically

⚡⚡⚡⚡⚡ Bootstrap project with parallel execution

⚡⚡ Brainstorm a feature

⚡⚡⚡ Start coding & testing an existing plan

**MUST READ** `CLAUDE.md` then **THINK HARDER** to start working on the following plan follow the Orchestration Protocol, Core Responsibilities, Subagents Team and Development Rules:

⚡⚡ Start coding an existing plan (no testing)

⚡ Execute parallel or sequential phases based on plan structure

⚡⚡⚡ Implement a feature [step by step]

⚡⚡ Implement a feature automatically ("trust me bro")

⚡ No research. Only scout, plan & implement ["trust me bro"]

⚡⚡⚡ Plan parallel phases & execute with fullstack-developer agents

⚡⚡ Debugging technical issues and providing solutions.

⚡⚡⚡⚡ Analyze the codebase and create initial documentation

Use `docs-manager` agent to analyze the codebase based on `docs/codebase-summary.md` and respond with a summary report.

⚡⚡⚡ Analyze the codebase and update documentation

⚡⚡ Analyze and fix issues [INTELLIGENT ROUTING]

⚡ Analyze Github Actions logs and fix issues

⚡ Analyze and fix small issues [FAST]

⚡⚡⚡ Use subagents to plan and fix hard issues

⚡ Analyze logs and fix issues

⚡⚡ Analyze & fix issues with parallel fullstack-developer agents

⚡⚡ Run test suite and fix issues

⚡ Fix type errors

⚡⚡ Analyze and fix UI issues

Stage all files and create a commit.

Stage, commit and push all code in the current branch

TO_BRANCH: $1 (defaults to `main`)

TO_BRANCH: $1 (defaults to `main`)

⚡⚡⚡ Intelligent plan creation with prompt enhancement

Read and analyze the plans, then write journal entries and archive specific plans or all plans in the `plans` directory.

Analyze Github Actions logs and provide a plan to fix the issues

Create a CRO plan for the given content

⚡⚡ No research. Only analyze and create an implementation plan

⚡⚡⚡ Research, analyze, and create an implementation plan

⚡⚡⚡ Create detailed plan with parallel-executable phases

⚡⚡⚡⚡ Research & create an implementation plan with 2 approaches

Validate plan with critical questions interview

⚡⚡⚡ Scan & analyze the codebase.

⚡⚡⚡ Ultrathink edge cases, then parallel verify with code-reviewers

Search the codebase for files needed to complete the task using a fast, token efficient agent.

Utilize external agentic tools to scout given directories or explore the codebase for files needed to complete the task using a fast, token efficient agent.

Think harder.

Create a new agent skill

Fix the agent skill based on `logs.txt` file.

Think harder.

Think harder.

Think harder.

Think harder.

⚡ Run tests locally and analyze the summary report.

Activate the chrome-devtools skill.

⚡ Review recent changes and wrap up the work

Use this agent when you need to brainstorm software solutions, evaluate architectural approaches, or debate technical decisions before implementation. Examples: - <example> Context: User wants to add a new feature to their application user: "I want to add real-time notifications to my web app" assistant: "Let me use the brainstormer agent to explore the best approaches for implementing real-time notifications" <commentary> The user needs architectural guidance for a new feature, so use the brainstormer to evaluate options like WebSockets, Server-Sent Events, or push notifications. </commentary> </example> - <example> Context: User is considering a major refactoring decision user: "Should I migrate from REST to GraphQL for my API?" assistant: "I'll engage the brainstormer agent to analyze this architectural decision" <commentary> This requires evaluating trade-offs, considering existing codebase, and debating pros/cons - perfect for the brainstormer. </commentary> </example> - <example> Context: User has a complex technical problem to solve user: "I'm struggling with how to handle file uploads that can be several GB in size" assistant: "Let me use the brainstormer agent to explore efficient approaches for large file handling" <commentary> This requires researching best practices, considering UX/DX implications, and evaluating multiple technical approaches. </commentary> </example>

Use this agent when you need comprehensive code review and quality assessment. This includes: after implementing new features or refactoring existing code, before merging pull requests or deploying to production, when investigating code quality issues or technical debt, when you need security vulnerability assessment, or when optimizing performance bottlenecks. Examples: <example> Context: The user has just implemented a new API endpoint and wants to ensure code quality. user: "I've finished implementing the user authentication endpoint" assistant: "I'll review the authentication endpoint implementation for code quality and security." <commentary> Since new code has been written, use the Task tool to launch the code-reviewer agent to perform comprehensive quality assessment. </commentary> assistant: "Let me use the code-reviewer agent to analyze the recent changes" </example> <example> Context: The user wants to check recent code changes for potential issues. user: "Can you review the changes I just made to the database service?" assistant: "I'll launch the code-reviewer agent to analyze the database service changes." <commentary> The user explicitly asks for code review, so use the code-reviewer agent to assess the recent modifications. </commentary> </example> <example> Context: After refactoring, proactive code review is needed. user: "I've refactored the WebSocket handler to improve performance" assistant: "Good work on the refactoring. Let me review it for quality and performance." <commentary> After refactoring work, proactively use the code-reviewer agent to ensure quality standards are met. </commentary> assistant: "I'll use the code-reviewer agent to validate the refactored WebSocket handler" </example>

Use this agent when you need to investigate issues, analyze system behavior, diagnose performance problems, examine database structures, collect and analyze logs from servers or CI/CD pipelines, run tests for debugging purposes, or optimize system performance. This includes troubleshooting errors, identifying bottlenecks, analyzing failed deployments, investigating test failures, and creating diagnostic reports. Examples: <example> Context: The user needs to investigate why an API endpoint is returning 500 errors. user: "The /api/users endpoint is throwing 500 errors" assistant: "I'll use the debugger agent to investigate this issue" <commentary> Since this involves investigating an issue, use the Task tool to launch the debugger agent. </commentary> </example> <example> Context: The user wants to analyze why the CI/CD pipeline is failing. user: "The GitHub Actions workflow keeps failing on the test step" assistant: "Let me use the debugger agent to analyze the CI/CD pipeline logs and identify the issue" <commentary> This requires analyzing CI/CD logs and test failures, so use the debugger agent. </commentary> </example> <example> Context: The user notices performance degradation in the application. user: "The application response times have increased by 300% since yesterday" assistant: "I'll launch the debugger agent to analyze system behavior and identify performance bottlenecks" <commentary> Performance analysis and bottleneck identification requires the debugger agent. </commentary> </example>

Use this agent when you need to manage technical documentation, establish implementation standards, analyze and update existing documentation based on code changes, write or update Product Development Requirements (PDRs), organize documentation for developer productivity, or produce documentation summary reports. This includes tasks like reviewing documentation structure, ensuring docs are up-to-date with codebase changes, creating new documentation for features, and maintaining consistency across all technical documentation.

Stage, commit, and push code changes with conventional commits. Use when user says "commit", "push", or finishes a feature/fix.

Use this agent when you need to research, analyze, and create comprehensive implementation plans for new features, system architectures, or complex technical solutions. This agent should be invoked before starting any significant implementation work, when evaluating technical trade-offs, or when you need to understand the best approach for solving a problem. Examples: <example>Context: User needs to implement a new authentication system. user: 'I need to add OAuth2 authentication to our app' assistant: 'I'll use the planner agent to research OAuth2 implementations and create a detailed plan' <commentary>Since this is a complex feature requiring research and planning, use the Task tool to launch the planner agent.</commentary></example> <example>Context: User wants to refactor the database layer. user: 'We need to migrate from SQLite to PostgreSQL' assistant: 'Let me invoke the planner agent to analyze the migration requirements and create a comprehensive plan' <commentary>Database migration requires careful planning, so use the planner agent to research and plan the approach.</commentary></example> <example>Context: User reports performance issues. user: 'The app is running slowly on older devices' assistant: 'I'll use the planner agent to investigate performance optimization strategies and create an implementation plan' <commentary>Performance optimization needs research and planning, so delegate to the planner agent.</commentary></example>

Use this agent when you need comprehensive project oversight and coordination. Examples: <example>Context: User has completed a major feature implementation and needs to track progress against the implementation plan. user: 'I just finished implementing the WebSocket terminal communication feature. Can you check our progress and update the plan?' assistant: 'I'll use the project-manager agent to analyze the implementation against our plan, track progress, and provide a comprehensive status report.' <commentary>Since the user needs project oversight and progress tracking against implementation plans, use the project-manager agent to analyze completeness and update plans.</commentary></example> <example>Context: Multiple agents have completed various tasks and the user needs a consolidated view of project status. user: 'The backend-developer and tester agents have finished their work. What's our overall project status?' assistant: 'Let me use the project-manager agent to collect all implementation reports, analyze task completeness, and provide a detailed summary of achievements and next steps.' <commentary>Since multiple agents have completed work and comprehensive project analysis is needed, use the project-manager agent to consolidate reports and track progress.</commentary></example>

Use this agent when you need to conduct comprehensive research on software development topics, including investigating new technologies, finding documentation, exploring best practices, or gathering information about plugins, packages, and open source projects. This agent excels at synthesizing information from multiple sources including searches, website content, YouTube videos, and technical documentation to produce detailed research reports. <example>Context: The user needs to research a new technology stack for their project. user: "I need to understand the latest developments in React Server Components and best practices for implementation" assistant: "I'll use the researcher agent to conduct comprehensive research on React Server Components, including latest updates, best practices, and implementation guides." <commentary>Since the user needs in-depth research on a technical topic, use the Task tool to launch the researcher agent to gather information from multiple sources and create a detailed report.</commentary></example> <example>Context: The user wants to find the best authentication libraries for their Flutter app. user: "Research the top authentication solutions for Flutter apps with biometric support" assistant: "Let me deploy the researcher agent to investigate authentication libraries for Flutter with biometric capabilities." <commentary>The user needs research on specific technical requirements, so use the researcher agent to search for relevant packages, documentation, and implementation examples.</commentary></example> <example>Context: The user needs to understand security best practices for API development. user: "What are the current best practices for securing REST APIs in 2024?" assistant: "I'll engage the researcher agent to research current API security best practices and compile a comprehensive report." <commentary>This requires thorough research on security practices, so use the researcher agent to gather information from authoritative sources and create a detailed summary.</commentary></example>

Use this agent when you need to quickly locate relevant files across a large codebase to complete a specific task using external agentic tools (Gemini, OpenCode, etc.). This agent is particularly useful when: <example> Context: User needs to implement a new payment provider integration and needs to find all payment-related files. user: "I need to add Stripe as a new payment provider. Can you help me find all the relevant files?" assistant: "I'll use the scout agent to quickly search for payment-related files across the codebase." <Task tool call to scout with query about payment provider files> <commentary> The user needs to locate payment integration files. The scout agent will efficiently search multiple directories in parallel using external agentic tools to find all relevant payment processing files, API routes, and configuration files. </commentary> </example> <example> Context: User is debugging an authentication issue and needs to find all auth-related components. user: "There's a bug in the login flow. I need to review all authentication files." assistant: "Let me use the scout agent to locate all authentication-related files for you." <Task tool call to scout with query about authentication files> <commentary> The user needs to debug authentication. The scout agent will search across app/, lib/, and api/ directories in parallel to quickly identify all files related to authentication, sessions, and user management. </commentary> </example> <example> Context: User wants to understand how database migrations work in the project. user: "How are database migrations structured in this project?" assistant: "I'll use the scout agent to find all migration-related files and database schema definitions." <Task tool call to scout with query about database migrations> <commentary> The user needs to understand database structure. The scout agent will efficiently search db/, lib/, and schema directories to locate migration files, schema definitions, and database configuration files. </commentary> </example> Proactively use this agent when: - Beginning work on a feature that spans multiple directories - User mentions needing to "find", "locate", or "search for" files - Starting a debugging session that requires understanding file relationships - User asks about project structure or where specific functionality lives - Before making changes that might affect multiple parts of the codebase

Use this agent when you need to quickly locate relevant files across a large codebase to complete a specific task. This agent is particularly useful when: <example> Context: User needs to implement a new payment provider integration and needs to find all payment-related files. user: "I need to add Stripe as a new payment provider. Can you help me find all the relevant files?" assistant: "I'll use the scout agent to quickly search for payment-related files across the codebase." <Task tool call to scout with query about payment provider files> <commentary> The user needs to locate payment integration files. The scout agent will efficiently search multiple directories in parallel using external agentic tools to find all relevant payment processing files, API routes, and configuration files. </commentary> </example> <example> Context: User is debugging an authentication issue and needs to find all auth-related components. user: "There's a bug in the login flow. I need to review all authentication files." assistant: "Let me use the scout agent to locate all authentication-related files for you." <Task tool call to scout with query about authentication files> <commentary> The user needs to debug authentication. The scout agent will search across app/, lib/, and api/ directories in parallel to quickly identify all files related to authentication, sessions, and user management. </commentary> </example> <example> Context: User wants to understand how database migrations work in the project. user: "How are database migrations structured in this project?" assistant: "I'll use the scout agent to find all migration-related files and database schema definitions." <Task tool call to scout with query about database migrations> <commentary> The user needs to understand database structure. The scout agent will efficiently search db/, lib/, and schema directories to locate migration files, schema definitions, and database configuration files. </commentary> </example> Proactively use this agent when: - Beginning work on a feature that spans multiple directories - User mentions needing to "find", "locate", or "search for" files - Starting a debugging session that requires understanding file relationships - User asks about project structure or where specific functionality lives - Before making changes that might affect multiple parts of the codebase

Use this agent when you need to validate code quality through testing, including running unit and integration tests, analyzing test coverage, validating error handling, checking performance requirements, or verifying build processes. This agent should be called after implementing new features or making significant code changes to ensure everything works as expected. Examples: <example> Context: The user has just finished implementing a new API endpoint and wants to ensure it works correctly. user: "I've implemented the new user authentication endpoint" assistant: "Great! Now let me use the tester agent to run the test suite and validate the implementation" <commentary> Since new code has been written, use the Task tool to launch the tester agent to run tests and ensure everything works properly. </commentary> </example> <example> Context: The user wants to check test coverage after adding new features. user: "Can you check if our test coverage is still above 80%?" assistant: "I'll use the tester agent to analyze the current test coverage and provide a detailed report" <commentary> The user is asking about test coverage metrics, so use the tester agent to run coverage analysis. </commentary> </example> <example> Context: After fixing a bug, ensuring the fix doesn't break existing functionality. user: "I've fixed the database connection issue in the auth module" assistant: "Let me use the tester agent to run the test suite and ensure the fix doesn't introduce any regressions" <commentary> After bug fixes, use the tester agent to validate that existing tests still pass. </commentary> </example>

Build robust backend systems with modern technologies (Node.js, Python, Go, Rust), frameworks (NestJS, FastAPI, Django), databases (PostgreSQL, MongoDB, Redis), APIs (REST, GraphQL, gRPC), authentication (OAuth 2.1, JWT), testing strategies, security best practices (OWASP Top 10), performance optimization, scalability patterns (microservices, caching, sharding), DevOps practices (Docker, Kubernetes, CI/CD), and monitoring. Use when designing APIs, implementing authentication, optimizing database queries, setting up CI/CD pipelines, handling security vulnerabilities, building microservices, or developing production-ready backend systems.

Collaborative solution brainstorming with brutal honesty, multi-approach analysis, principle-driven recommendations. Use for ideation, architecture decisions, technical debates, feature exploration, problem-solving, trade-off analysis, feasibility assessment, and design discussions.

Browser automation, debugging, and performance analysis using Puppeteer CLI scripts. Use for automating browsers, taking screenshots, analyzing performance, monitoring network traffic, web scraping, form automation, and JavaScript debugging.

Use when receiving code review feedback (especially if unclear or technically questionable), when completing tasks or major features requiring review before proceeding, or before making any completion/success claims. Covers three practices - receiving feedback with technical rigor over performative agreement, requesting reviews via code-reviewer subagent, and verification gates requiring evidence before any status claims. Essential for subagent-driven development, pull requests, and preventing false completion claims.

Work with MongoDB (document database, BSON documents, aggregation pipelines, Atlas cloud) and PostgreSQL (relational database, SQL queries, psql CLI, pgAdmin). Use when designing database schemas, writing queries and aggregations, optimizing indexes for performance, performing database migrations, configuring replication and sharding, implementing backup and restore strategies, managing database users and permissions, analyzing query performance, or administering production databases.

Systematic debugging framework ensuring root cause investigation before fixes. Includes four-phase debugging process, backward call stack tracing, multi-layer validation, and verification protocols. Use when encountering bugs, test failures, unexpected behavior, performance issues, or before claiming work complete. Prevents random fixes, masks over symptoms, and false completion claims.

Deploy and manage cloud infrastructure on Cloudflare (Workers, R2, D1, KV, Pages, Durable Objects, Browser Rendering), Docker containers, and Google Cloud Platform (Compute Engine, GKE, Cloud Run, App Engine, Cloud Storage). Use when deploying serverless functions to the edge, configuring edge computing solutions, managing Docker containers and images, setting up CI/CD pipelines, optimizing cloud infrastructure costs, implementing global caching strategies, working with cloud databases, or building cloud-native applications.

Search technical documentation using executable scripts to detect query type, fetch from llms.txt sources (context7.com), and analyze results. Use when user needs: (1) Topic-specific documentation (features/components/concepts), (2) Library/framework documentation, (3) GitHub repository analysis, (4) Documentation discovery with automated agent distribution strategy

Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. When Claude needs to work with professional documents (.docx files) for: (1) Creating new documents, (2) Modifying or editing content, (3) Working with tracked changes, (4) Adding comments, or any other document tasks

Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms. When Claude needs to fill in a PDF form or programmatically process, generate, or analyze PDF documents at scale.

Presentation creation, editing, and analysis. When Claude needs to work with presentations (.pptx files) for: (1) Creating new presentations, (2) Modifying or editing content, (3) Working with layouts, (4) Adding comments or speaker notes, or any other presentation tasks

Comprehensive spreadsheet creation, editing, and analysis with support for formulas, formatting, data analysis, and visualization. When Claude needs to work with spreadsheets (.xlsx, .xlsm, .csv, .tsv, etc) for: (1) Creating new spreadsheets with formulas and formatting, (2) Reading or analyzing data, (3) Modify existing spreadsheets while preserving formulas, (4) Data analysis and visualization in spreadsheets, or (5) Recalculating formulas

Use when you need to plan technical solutions that are scalable, secure, and maintainable.

Apply systematic problem-solving techniques for complexity spirals (simplification cascades), innovation blocks (collision-zone thinking), recurring patterns (meta-pattern recognition), assumption constraints (inversion exercise), scale uncertainty (scale game), and dispatch when stuck. Techniques derived from Microsoft Amplifier project patterns adapted for immediate application.

Package entire code repositories into single AI-friendly files using Repomix. Capabilities include pack codebases with customizable include/exclude patterns, generate multiple output formats (XML, Markdown, plain text), preserve file structure and context, optimize for AI consumption with token counting, filter by file types and directories, add custom headers and summaries. Use when packaging codebases for AI analysis, creating repository snapshots for LLM context, analyzing third-party libraries, preparing for security audits, generating documentation context, or evaluating unfamiliar codebases.

Use when you need to research, analyze, and plan technical solutions that are scalable, secure, and maintainable.

Apply structured, reflective problem-solving for complex tasks requiring multi-step analysis, revision capability, and hypothesis verification. Use for complex problem decomposition, adaptive planning, analysis needing course correction, problems with unclear scope, multi-step solutions, and hypothesis-driven work.

---

Build modern full-stack web applications with Next.js (App Router, Server Components, RSC, PPR, SSR, SSG, ISR), Turborepo (monorepo management, task pipelines, remote caching, parallel execution), and RemixIcon (3100+ SVG icons in outlined/filled styles). Use when creating React applications, implementing server-side rendering, setting up monorepos with multiple packages, optimizing build performance and caching strategies, adding icon libraries, managing shared dependencies, or working with TypeScript full-stack projects.