aiwf-experts

Use this agent when you need to integrate AI/ML models into Node.js, NestJS, or React applications. This includes connecting to hosted AI services (AWS SageMaker, Bedrock, GCP Vertex AI), implementing frontend components to display AI outputs, setting up data pipelines for model training/inference, and ensuring secure and performant AI integrations. Examples: <example> Context: The user wants to add AI-powered features to their application. user: "I need to integrate a recommendation system using AWS SageMaker into our NestJS backend" assistant: "I'll use the ai-native-specialist agent to help integrate the SageMaker recommendation model into your NestJS backend." <commentary> Since the user needs to integrate an AI/ML model (SageMaker) into a NestJS application, use the ai-native-specialist agent. </commentary> </example> <example> Context: The user is building a React frontend that needs to display AI predictions. user: "Create a React component that displays real-time predictions from our Vertex AI model" assistant: "Let me use the ai-native-specialist agent to create a React component for displaying Vertex AI predictions." <commentary> The user needs a React component to display AI outputs, which is a core responsibility of the ai-native-specialist agent. </commentary> </example> <example> Context: The user needs to set up data pipelines for ML model training. user: "Set up a BigQuery data pipeline to prepare training data for our TensorFlow model" assistant: "I'll use the ai-native-specialist agent to set up the BigQuery data pipeline for your TensorFlow model training." <commentary> Setting up data pipelines for ML frameworks is within the ai-native-specialist agent's expertise. </commentary> </example>

Use this agent when you need to design, implement, or optimize AWS serverless architectures, including Lambda functions, Step Functions workflows, API Gateway configurations, and their integration with AI/ML services. This includes tasks like creating new serverless functions, optimizing existing Lambda code for performance and cost, designing Step Functions state machines, configuring API Gateway endpoints, integrating with AWS AI services (SageMaker, Bedrock), and ensuring proper security and monitoring configurations. Examples: <example> Context: The user needs to create a new serverless function for processing data. user: "Create a Lambda function that processes incoming webhook data and stores it in DynamoDB" assistant: "I'll use the aws-serverless-architect agent to help design and implement this Lambda function with proper error handling and DynamoDB integration." <commentary> Since the user is asking for Lambda function creation with DynamoDB integration, use the aws-serverless-architect agent to handle the serverless implementation. </commentary> </example> <example> Context: The user wants to optimize their serverless architecture. user: "Our Lambda functions are experiencing high cold start times. Can you help optimize them?" assistant: "I'll use the aws-serverless-architect agent to analyze your Lambda functions and provide optimization strategies for reducing cold starts." <commentary> The user needs Lambda performance optimization, which is a core competency of the aws-serverless-architect agent. </commentary> </example> <example> Context: The user needs to integrate AI services with serverless architecture. user: "I need to create a Step Functions workflow that orchestrates multiple Lambda functions and calls Amazon Bedrock for text generation" assistant: "I'll use the aws-serverless-architect agent to design this Step Functions workflow with proper Lambda and Bedrock integration." <commentary> This involves Step Functions design with AI service integration, perfect for the aws-serverless-architect agent. </commentary> </example>

Use this agent when you need to design, implement, or review backend systems with a focus on Clean Architecture principles and SOLID design patterns. This includes creating domain-driven designs, implementing repository patterns, designing use cases, setting up dependency injection, structuring backend applications with proper layer separation, and ensuring code follows SOLID principles (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion). <example> Context: 사용자가 새로운 백엔드 API를 설계하거나 기존 코드를 리팩토링할 때 user: "사용자 인증 시스템을 구현해주세요" assistant: "백엔드 클린 아키텍처 전문가를 사용하여 SOLID 원칙을 준수하는 인증 시스템을 설계하겠습니다" <commentary> 사용자가 백엔드 시스템 구현을 요청했으므로, backend-clean-architect 에이전트를 사용하여 클린 아키텍처와 SOLID 원칙을 적용한 설계를 진행합니다. </commentary> </example> <example> Context: 기존 백엔드 코드의 아키텍처 개선이 필요할 때 user: "이 서비스 레이어가 너무 복잡한데 개선해주세요" assistant: "backend-clean-architect 에이전트를 활용하여 SOLID 원칙에 따라 서비스 레이어를 리팩토링하겠습니다" <commentary> 복잡한 서비스 레이어의 개선이 필요하므로, 클린 아키텍처 전문가 에이전트를 사용하여 적절한 책임 분리와 의존성 관리를 수행합니다. </commentary> </example>

Use this agent when you need to review recently written code for adherence to best practices, architectural consistency, and system integration. This agent examines code quality, questions implementation decisions, and ensures alignment with project standards and the broader system architecture. Examples: <example> Context: The user has just implemented a new API endpoint and wants to ensure it follows project patterns. user: "I've added a new workflow status endpoint to the form service" assistant: "I'll review your new endpoint implementation using the code-architecture-reviewer agent" <commentary> Since new code was written that needs review for best practices and system integration, use the Task tool to launch the code-architecture-reviewer agent. </commentary> </example> <example> Context: The user has created a new React component and wants feedback on the implementation. user: "I've finished implementing the WorkflowStepCard component" assistant: "Let me use the code-architecture-reviewer agent to review your WorkflowStepCard implementation" <commentary> The user has completed a component that should be reviewed for React best practices and project patterns. </commentary> </example> <example> Context: The user has refactored a service class and wants to ensure it still fits well within the system. user: "I've refactored the AuthenticationService to use the new token validation approach" assistant: "I'll have the code-architecture-reviewer agent examine your AuthenticationService refactoring" <commentary> A refactoring has been done that needs review for architectural consistency and system integration. </commentary> </example>

Use this agent when you need to fix React frontend build errors, resolve linting issues, and ensure code formatting compliance with Prettier. This agent should be triggered after build failures or before committing code to ensure all quality checks pass. Examples: <example> Context: The user has just written React components and needs to ensure they pass all build checks. user: "I've finished implementing the new dashboard components" assistant: "Let me run the react-build-fixer agent to ensure everything passes our build pipeline" <commentary> Since new React code has been written, use the Task tool to launch the react-build-fixer agent to check and fix any build, lint, or formatting issues. </commentary> </example> <example> Context: A build failure has occurred in the CI/CD pipeline. user: "The frontend build is failing in CI" assistant: "I'll use the react-build-fixer agent to diagnose and fix the build issues" <commentary> Build failure reported, use the Task tool to launch the react-build-fixer agent to resolve the issues. </commentary> </example> <example> Context: Before creating a pull request. user: "I'm ready to create a PR for the authentication feature" assistant: "First, let me run the react-build-fixer agent to ensure all code quality checks will pass" <commentary> Before PR submission, proactively use the Task tool to launch the react-build-fixer agent to prevent CI failures. </commentary> </example>

Use this agent when you need to create, update, or enhance documentation for any part of the codebase. This includes developer documentation, README files, API documentation, data flow diagrams, testing documentation, or architectural overviews. The agent will gather comprehensive context from memory, existing documentation, and related files to produce high-quality documentation that captures the complete picture. <example> Context: User has just implemented a new authentication flow and needs documentation. user: "I've finished implementing the JWT cookie-based authentication. Can you document this?" assistant: "I'll use the documentation-architect agent to create comprehensive documentation for the authentication system." <commentary> Since the user needs documentation for a newly implemented feature, use the documentation-architect agent to gather all context and create appropriate documentation. </commentary> </example> <example> Context: User is working on a complex workflow engine and needs to document the data flow. user: "The workflow engine is getting complex. We need to document how data flows through the system." assistant: "Let me use the documentation-architect agent to analyze the workflow engine and create detailed data flow documentation." <commentary> The user needs data flow documentation for a complex system, which is a perfect use case for the documentation-architect agent. </commentary> </example> <example> Context: User has made changes to an API and needs to update the API documentation. user: "I've added new endpoints to the form service API. The docs need updating." assistant: "I'll launch the documentation-architect agent to update the API documentation with the new endpoints." <commentary> API documentation needs updating after changes, so use the documentation-architect agent to ensure comprehensive and accurate documentation. </commentary> </example>

Use this agent when you need to rapidly design and prototype SaaS products using modern tech stacks like Next.js, next-forge, Supabase, Stripe, TailwindCSS, shadcn/ui, and Clerk. This agent specializes in creating production-ready MVP architectures with proper feature-based organization and full-stack implementation. Examples: <example>Context: User wants to build a new SaaS product for project management. user: "I want to create a project management SaaS with team collaboration features" assistant: "I'll use the saas-mvp-architect agent to design and implement a comprehensive SaaS MVP with proper architecture, database schema, and feature organization."</example> <example>Context: User needs to add a subscription billing system to their existing app. user: "How do I integrate Stripe subscriptions into my next-forge app?" assistant: "Let me use the saas-mvp-architect agent to implement Stripe subscription integration following next-forge conventions and best practices."</example>

Use this agent when you need to fix build errors, lint issues, or formatting problems in NestJS, Fastify, or Express backend code. This agent should be called after writing backend code or when build failures occur. Examples: <example> Context: The user has just written a new NestJS controller and needs to ensure it passes all build checks. user: "I've added a new user controller to the backend" assistant: "I'll use the backend-build-fixer agent to ensure your new controller passes all build requirements" <commentary> Since new backend code was written, use the backend-build-fixer agent to run lint, prettier, and build checks. </commentary> </example> <example> Context: Build pipeline is failing due to TypeScript or lint errors. user: "The backend build is failing in CI/CD" assistant: "Let me use the backend-build-fixer agent to diagnose and fix the build issues" <commentary> Build failure reported, use the backend-build-fixer agent to fix lint, type, and formatting issues. </commentary> </example> <example> Context: After refactoring backend code. user: "I've refactored the authentication module" assistant: "I'll run the backend-build-fixer agent to ensure all code standards are met after the refactoring" <commentary> Code refactoring completed, use the backend-build-fixer agent to verify build integrity. </commentary> </example>

Use this agent when you encounter frontend errors, whether they appear during the build process (TypeScript, bundling, linting errors) or at runtime in the browser console (JavaScript errors, React errors, network issues). This agent specializes in diagnosing and fixing frontend issues with precision. Examples: - <example> Context: User encounters an error in their React application user: "I'm getting a 'Cannot read property of undefined' error in my React component" assistant: "I'll use the frontend-error-fixer agent to diagnose and fix this runtime error" <commentary> Since the user is reporting a browser console error, use the frontend-error-fixer agent to investigate and resolve the issue. </commentary> </example> - <example> Context: Build process is failing user: "My build is failing with a TypeScript error about missing types" assistant: "Let me use the frontend-error-fixer agent to resolve this build error" <commentary> The user has a build-time error, so the frontend-error-fixer agent should be used to fix the TypeScript issue. </commentary> </example> - <example> Context: User notices errors in browser console while testing user: "I just implemented a new feature and I'm seeing some errors in the console when I click the submit button" assistant: "I'll launch the frontend-error-fixer agent to investigate these console errors using the browser tools" <commentary> Runtime errors are appearing during user interaction, so the frontend-error-fixer agent should investigate using browser tools MCP. </commentary> </example>

Use this agent when you need comprehensive code review after writing or modifying code. This agent should be used proactively after completing any logical chunk of code development, such as implementing a new feature, fixing a bug, or refactoring existing code. Examples: <example>Context: The user just implemented a new authentication function and wants it reviewed before committing. user: "I just finished implementing the login function with JWT token validation. Here's the code: [code snippet]" assistant: "Let me use the code-reviewer agent to provide a comprehensive review of your authentication implementation." <commentary>Since the user has completed a code implementation, use the code-reviewer agent to analyze the code for quality, security, and maintainability issues.</commentary></example> <example>Context: The user has refactored a database query function and wants feedback. user: "I've optimized the user search query to improve performance. Can you check if there are any issues?" assistant: "I'll use the code-reviewer agent to analyze your optimized query for potential issues and improvements." <commentary>The user has made code modifications and is seeking review, so the code-reviewer agent should be used to evaluate the changes.</commentary></example>

Use this agent when you need to debug authentication-related issues with API routes, including 401/403 errors, cookie problems, JWT token issues, route registration problems, or when routes are returning 'not found' despite being defined. This agent specializes in the your project application's Keycloak/cookie-based authentication patterns. Examples: - <example> Context: User is experiencing authentication issues with an API route user: "I'm getting a 401 error when trying to access the /api/workflow/123 route even though I'm logged in" assistant: "I'll use the auth-route-debugger agent to investigate this authentication issue" <commentary> Since the user is having authentication problems with a route, use the auth-route-debugger agent to diagnose and fix the issue. </commentary> </example> - <example> Context: User reports a route is not being found despite being defined user: "The POST /form/submit route returns 404 but I can see it's defined in the routes file" assistant: "Let me launch the auth-route-debugger agent to check the route registration and potential conflicts" <commentary> Route not found errors often relate to registration order or naming conflicts, which the auth-route-debugger specializes in. </commentary> </example> - <example> Context: User needs help testing an authenticated endpoint user: "Can you help me test if the /api/user/profile endpoint is working correctly with authentication?" assistant: "I'll use the auth-route-debugger agent to test this authenticated endpoint properly" <commentary> Testing authenticated routes requires specific knowledge of the cookie-based auth system, which this agent handles. </commentary> </example>

Use this agent when you need to test routes after implementing or modifying them. This agent focuses on verifying complete route functionality - ensuring routes handle data correctly, create proper database records, and return expected responses. The agent also reviews route implementation for potential improvements. Examples: <example> Context: The user has just implemented a new POST route for form submissions. user: "I've added a new POST route to /form/submit that creates submissions" assistant: "I'll test the route to ensure it's working properly" <commentary> Since a new route was created, use the auth-route-tester agent to verify it creates records correctly and returns the expected response. </commentary> assistant: "Let me use the auth-route-tester agent to verify the route functionality and review the implementation" </example> <example> Context: The user has modified a workflow launch route. user: "I updated the monthly report launch route with new permission checks" assistant: "I'll test the route to ensure it still creates workflows correctly" <commentary> Changes to existing routes require testing the full functionality, so use the auth-route-tester agent. </commentary> assistant: "I'll use the auth-route-tester agent to test the complete workflow creation process" </example> <example> Context: The user has implemented a new API endpoint. user: "I added a new endpoint to fetch user tasks" assistant: "I should test the endpoint to verify it returns the correct data" <commentary> New endpoints need functional testing to ensure they work as expected. </commentary> assistant: "Let me launch the auth-route-tester agent to verify the endpoint returns tasks properly" </example>

Automatically fix TypeScript compilation errors

Use this agent when you need to create, customize, or optimize data visualizations using charting libraries like D3.js, Highcharts, Chart.js, or other visualization frameworks. This includes building custom charts, implementing complex data visualizations, optimizing chart performance, or solving visualization-related technical challenges. Examples: <example> Context: The user needs to create a complex data visualization. user: "I need to create an interactive dashboard with multiple chart types showing sales data" assistant: "I'll use the chart-visualization-expert agent to help design and implement the dashboard with appropriate charting libraries." <commentary> Since the user needs complex data visualization work, use the Task tool to launch the chart-visualization-expert agent. </commentary> </example> <example> Context: The user wants to customize a chart beyond standard library capabilities. user: "Can you help me create a custom radial bar chart with animated transitions?" assistant: "Let me engage the chart-visualization-expert agent to implement this custom visualization." <commentary> Custom chart implementation requires specialized knowledge, so use the chart-visualization-expert agent. </commentary> </example> <example> Context: The user is having performance issues with their charts. user: "My D3 chart is rendering slowly with 10,000 data points" assistant: "I'll use the chart-visualization-expert agent to analyze and optimize your D3 chart performance." <commentary> Chart optimization requires deep library knowledge, so use the chart-visualization-expert agent. </commentary> </example>

Use this agent when you need to refactor code for better organization, cleaner architecture, or improved maintainability. This includes reorganizing file structures, breaking down large components into smaller ones, updating import paths after file moves, fixing loading indicator patterns, and ensuring adherence to project best practices. The agent excels at comprehensive refactoring that requires tracking dependencies and maintaining consistency across the entire codebase. <example> Context: The user wants to reorganize a messy component structure with large files and poor organization. user: "This components folder is a mess with huge files. Can you help refactor it?" assistant: "I'll use the code-refactor-master agent to analyze the component structure and create a better organization scheme." <commentary> Since the user needs help with refactoring and reorganizing components, use the code-refactor-master agent to analyze the current structure and propose improvements. </commentary> </example> <example> Context: The user has identified multiple components using early returns with loading indicators instead of proper loading components. user: "I noticed we have loading returns scattered everywhere instead of using LoadingOverlay" assistant: "Let me use the code-refactor-master agent to find all instances of early return loading patterns and refactor them to use the proper loading components." <commentary> The user has identified a pattern that violates best practices, so use the code-refactor-master agent to systematically find and fix all occurrences. </commentary> </example> <example> Context: The user wants to break down a large component file into smaller, more manageable pieces. user: "The Dashboard.tsx file is over 2000 lines and becoming unmaintainable" assistant: "I'll use the code-refactor-master agent to analyze the Dashboard component and extract it into smaller, focused components." <commentary> The user needs help breaking down a large component, which requires careful analysis of dependencies and proper extraction - perfect for the code-refactor-master agent. </commentary> </example>

Use this agent when you need to develop SaaS applications using Convex, including database schema design, serverless functions, real-time features, authentication integration, subscription billing, webhook handling, and overall Convex architecture. This agent specializes in building production-ready SaaS backends with Convex. Examples: <example> Context: User is building a SaaS application with Convex user: "I need to set up a subscription system with Convex" assistant: "I'll use the convex-saas-developer agent to help you design and implement a subscription system with Convex." <commentary> Since the user needs help with Convex-based subscription system, use the Task tool to launch the convex-saas-developer agent. </commentary> </example> <example> Context: User needs help with Convex database schema user: "How should I structure my Convex schema for a multi-tenant SaaS?" assistant: "Let me use the convex-saas-developer agent to help you design an optimal Convex schema for multi-tenancy." <commentary> The user needs Convex-specific schema design guidance, so use the convex-saas-developer agent. </commentary> </example> <example> Context: User is implementing real-time features user: "I want to add real-time notifications to my Convex app" assistant: "I'll use the convex-saas-developer agent to implement real-time notifications using Convex's reactive features." <commentary> Real-time features with Convex require specialized knowledge, use the convex-saas-developer agent. </commentary> </example>

Use this agent when you need to analyze data, write SQL queries, perform BigQuery operations, or generate data insights. This agent should be used proactively for any data-related tasks including database queries, data visualization recommendations, statistical analysis, and interpreting data patterns. Examples: <example>Context: User is working with a database and needs to analyze sales data. user: "I need to find the top 10 customers by revenue this quarter" assistant: "I'll use the data-analyst agent to help you create the appropriate SQL query and analyze the results" <commentary>Since the user needs data analysis and SQL query help, use the data-analyst agent to provide expert assistance with database queries and insights.</commentary></example> <example>Context: User has uploaded a CSV file with customer data and wants insights. user: "Can you help me understand what this customer data is telling us?" assistant: "Let me use the data-analyst agent to examine your data and provide comprehensive insights" <commentary>The user is asking for data analysis and insights, which is exactly what the data-analyst agent specializes in.</commentary></example>

Use this agent when you need to implement backend changes in a NestJS application, especially when working with TypeScript, AWS Lambda, Firebase Authentication, or GCP BigQuery. This includes creating or modifying API endpoints, implementing authentication guards, optimizing Lambda functions, setting up data pipelines, or integrating AI-related features. Examples: <example> Context: User needs to add a new API endpoint to their NestJS application. user: "I need to create a new endpoint for user profile management" assistant: "I'll use the nestjs-specialist agent to help create that endpoint following NestJS best practices." <commentary> Since this involves creating a NestJS API endpoint, the nestjs-specialist agent is the appropriate choice. </commentary> </example> <example> Context: User wants to integrate Firebase Authentication into their NestJS app. user: "Can you help me add Firebase auth to protect my API routes?" assistant: "Let me use the nestjs-specialist agent to implement Firebase Authentication guards for your routes." <commentary> The request involves Firebase Authentication integration in NestJS, which is a core capability of this agent. </commentary> </example> <example> Context: User needs to optimize AWS Lambda functions in their NestJS application. user: "My Lambda functions are experiencing cold start issues" assistant: "I'll use the nestjs-specialist agent to analyze and optimize your Lambda handlers for better cold start performance." <commentary> AWS Lambda optimization is one of the specialized areas this agent handles. </commentary> </example>

Use this agent when you have a development plan that needs thorough review before implementation to identify potential issues, missing considerations, or better alternatives. Examples: <example>Context: User has created a plan to implement a new authentication system integration. user: "I've created a plan to integrate Auth0 with our existing Keycloak setup. Can you review this plan before I start implementation?" assistant: "I'll use the plan-reviewer agent to thoroughly analyze your authentication integration plan and identify any potential issues or missing considerations." <commentary>The user has a specific plan they want reviewed before implementation, which is exactly what the plan-reviewer agent is designed for.</commentary></example> <example>Context: User has developed a database migration strategy. user: "Here's my plan for migrating our user data to a new schema. I want to make sure I haven't missed anything critical before proceeding." assistant: "Let me use the plan-reviewer agent to examine your migration plan and check for potential database issues, rollback strategies, and other considerations you might have missed." <commentary>This is a perfect use case for the plan-reviewer agent as database migrations are high-risk operations that benefit from thorough review.</commentary></example>

Use this agent when you need to implement or modify React frontend components with TypeScript, especially when integrating Firebase Authentication or AI-driven UI features. This includes creating new components, updating existing ones, implementing authentication flows, displaying ML model outputs, writing tests, and optimizing performance. Examples: <example> Context: The user needs to create a new login component with Firebase Authentication. user: "Create a login page with Firebase authentication" assistant: "I'll use the react-ai-frontend agent to create a type-safe login component with Firebase Auth integration." <commentary> Since this involves creating React components with Firebase Authentication, the react-ai-frontend agent is the appropriate choice. </commentary> </example> <example> Context: The user wants to display AI model predictions in the UI. user: "Add a component to show real-time recommendation predictions from our ML model" assistant: "Let me use the react-ai-frontend agent to implement an AI-driven UI component for displaying the recommendations." <commentary> This task involves creating AI-driven UI components in React, which is exactly what the react-ai-frontend agent specializes in. </commentary> </example> <example> Context: The user needs to update existing components and add tests. user: "Update the UserProfile component to use the new API endpoints and add tests" assistant: "I'll use the react-ai-frontend agent to update the component and write comprehensive tests." <commentary> Updating React components and writing tests falls within the react-ai-frontend agent's expertise. </commentary> </example>

Use this agent when you need to analyze code structure and create comprehensive refactoring plans. This agent should be used PROACTIVELY for any refactoring requests, including when users ask to restructure code, improve code organization, modernize legacy code, or optimize existing implementations. The agent will analyze the current state, identify improvement opportunities, and produce a detailed step-by-step plan with risk assessment. Examples: - <example> Context: User wants to refactor a legacy authentication system user: "I need to refactor our authentication module to use modern patterns" assistant: "I'll use the refactor-planner agent to analyze the current authentication structure and create a comprehensive refactoring plan" <commentary> Since the user is requesting a refactoring task, use the Task tool to launch the refactor-planner agent to analyze and plan the refactoring. </commentary> </example> - <example> Context: User has just written a complex component that could benefit from restructuring user: "I've implemented the dashboard component but it's getting quite large" assistant: "Let me proactively use the refactor-planner agent to analyze the dashboard component structure and suggest a refactoring plan" <commentary> Even though not explicitly requested, proactively use the refactor-planner agent to analyze and suggest improvements. </commentary> </example> - <example> Context: User mentions code duplication issues user: "I'm noticing we have similar code patterns repeated across multiple services" assistant: "I'll use the refactor-planner agent to analyze the code duplication and create a consolidation plan" <commentary> Code duplication is a refactoring opportunity, so use the refactor-planner agent to create a systematic plan. </commentary> </example>

Use this agent when you need to analyze code or configuration changes for security vulnerabilities, compliance issues, or exposed sensitive data. This includes scanning for common vulnerabilities like XSS, SQL injection, and exposed secrets, as well as checking compliance with security standards like OWASP Top 10. Examples: <example> Context: The user has just implemented a new API endpoint that handles user input. user: "I've added a new endpoint for user registration. Can you check if it's secure?" assistant: "I'll use the security-analyst agent to analyze your new endpoint for potential security issues." <commentary> Since new code handling user input has been added, use the Task tool to launch the security-analyst agent to check for vulnerabilities. </commentary> </example> <example> Context: The user has made configuration changes to their application. user: "I've updated the database connection settings and API configurations" assistant: "Let me scan these configuration changes for any security concerns using the security scanner." <commentary> Configuration changes can introduce security risks, so use the security-analyst agent to review them. </commentary> </example> <example> Context: The user is preparing for a production deployment. user: "We're about to deploy to production. Can you do a security check?" assistant: "I'll perform a comprehensive security scan of your codebase before deployment." <commentary> Pre-deployment security checks are critical, use the security-analyst agent to ensure no vulnerabilities exist. </commentary> </example>

Use this agent when you need to create, update, or review technical documentation based on code changes or new features. This includes generating README files, API documentation, user guides, setup instructions, or any other developer-facing documentation. The agent will analyze code changes and automatically suggest appropriate documentation updates. Examples: - <example> Context: The user has just implemented a new API endpoint and wants to ensure the documentation is updated. user: "I've added a new user authentication endpoint to our API" assistant: "I see you've added a new authentication endpoint. Let me use the technical-writer agent to analyze the changes and update the API documentation accordingly." <commentary> Since new API functionality was added, use the Task tool to launch the technical-writer agent to generate or update the relevant API documentation. </commentary> </example> - <example> Context: The user has refactored a major component and the existing documentation may be outdated. user: "I've completely refactored the payment processing module with a new architecture" assistant: "That's a significant change to the payment processing module. I'll use the technical-writer agent to review the refactored code and update all related documentation to reflect the new architecture." <commentary> Major refactoring requires documentation updates, so use the technical-writer agent to ensure all docs accurately reflect the new implementation. </commentary> </example> - <example> Context: The user is preparing for a release and wants to ensure all documentation is up to date. user: "We're about to release v2.0, can you check if our docs are current?" assistant: "I'll use the technical-writer agent to scan for recent code changes and verify that all documentation is up to date for the v2.0 release." <commentary> Pre-release documentation review is a perfect use case for the technical-writer agent to ensure consistency between code and docs. </commentary> </example>

Use this agent when you need to research information on the internet, particularly for debugging issues, finding solutions to technical problems, or gathering comprehensive information from multiple sources. This agent excels at finding relevant discussions in GitHub issues, Reddit threads, Stack Overflow, forums, and other community resources. Use when you need creative search strategies, thorough investigation of a topic, or compilation of findings from diverse sources. Examples: - <example> Context: The user is encountering a specific error with a library and needs to find if others have solved it. user: "I'm getting a 'Module not found' error with the new version of webpack, can you help me debug this?" assistant: "I'll use the web-research-specialist agent to search for similar issues and solutions across various forums and repositories." <commentary> Since the user needs help debugging an issue that others might have encountered, use the web-research-specialist agent to search for solutions. </commentary> </example> - <example> Context: The user needs comprehensive information about a technology or approach. user: "I need to understand the pros and cons of different state management solutions for React." assistant: "Let me use the web-research-specialist agent to research and compile a detailed comparison of different state management solutions." <commentary> The user needs research and comparison from multiple sources, which is perfect for the web-research-specialist agent. </commentary> </example> - <example> Context: The user is implementing a feature and wants to see how others have approached it. user: "How do other developers typically implement infinite scrolling with virtualization?" assistant: "I'll use the web-research-specialist agent to research various implementation approaches and best practices from the community." <commentary> This requires researching multiple implementation approaches from various sources, ideal for the web-research-specialist agent. </commentary> </example>