development-agents

Bootstrap project configuration for all installed plugins

Comprehensive commit workflow with pre-commit checks and PR creation

Fetch and display all GitHub PR comments including inline review comments

Runs tests and sends output to Claude

Use this agent when you need to investigate, analyze, or understand code structure, patterns, dependencies, or implementations in a codebase. This includes finding where functions are defined or used, understanding code relationships, analyzing patterns across files, investigating bugs, or researching how specific features are implemented. The agent will leverage Serena LSP tools for semantic understanding, ast-grep for syntactic pattern matching, and text-based search for comprehensive analysis. Examples: <example> Context: User wants to understand how a specific feature is implemented across the codebase. user: "How is the authentication system implemented in this project?" assistant: "I'll use the codebase-researcher agent to investigate the authentication implementation." <commentary> The user is asking about understanding code implementation, which requires researching across multiple files and understanding relationships - perfect for the codebase-researcher agent. </commentary> </example> <example> Context: User needs to find all usages of a deprecated function to refactor them. user: "Find all places where the old_api_call() function is being used" assistant: "Let me use the codebase-researcher agent to find all usages of old_api_call() throughout the codebase." <commentary> Finding function usages across the codebase is a research task that benefits from LSP and ast-grep capabilities. </commentary> </example> <example> Context: User is debugging an issue and needs to trace through code execution paths. user: "I'm getting a null pointer exception in the payment module. Can you help me trace where this might be coming from?" assistant: "I'll use the codebase-researcher agent to trace through the payment module code and identify potential sources of the null pointer exception." <commentary> Debugging requires understanding code flow and relationships, which the codebase-researcher agent can analyze using multiple search strategies. </commentary> </example>

Use this agent when you need to research information that is not available in the current codebase or project documentation, such as external library documentation, API references, best practices, or general technical information. This includes researching third-party packages, understanding external APIs, finding solutions to technical problems, or gathering information about tools and technologies not present in the project. <example> Context: The user wants to understand how a third-party library works. user: "How does the testcontainers library work for PostgreSQL?" assistant: "I'll use the external-research-specialist agent to research information about the testcontainers library." <commentary> Since the user is asking about an external library that's not part of the codebase, use the external-research-specialist agent to gather information from web sources and documentation. </commentary> </example> <example> Context: The user needs information about best practices for a technology. user: "What are the best practices for using SQLAlchemy with async/await?" assistant: "Let me use the external-research-specialist agent to research SQLAlchemy async best practices." <commentary> The user is asking for general best practices that would require external research beyond the project's codebase. </commentary> </example> <example> Context: The user wants to know about a specific API or service. user: "What are the rate limits for the OpenAI API?" assistant: "I'll use the external-research-specialist agent to find current information about OpenAI API rate limits." <commentary> This requires researching external API documentation that isn't part of the project. </commentary> </example>

Use this agent when you need to implement self-contained coding tasks that require manual coding rather than mechanical transformations. Ideal for: implementing new functions/classes in a specific file, refactoring a module, adding type hints to a file, fixing lint errors in a specific area, updating test fixtures, or any narrowly-scoped implementation work. This agent works well in parallel with other focused-coder instances on different parts of the codebase. Examples: - User: "I need to add type hints to the user_repository.py file" Assistant: "I'll use the Task tool to launch the focused-coder agent to add type hints to user_repository.py" - User: "Please implement the new email validation function in utils/validators.py according to the spec in the design doc" Assistant: "I'll use the Task tool to launch the focused-coder agent to implement the email validation function in utils/validators.py" - User: "The linter is complaining about unused imports in src/family_assistant/tools/calendar.py" Assistant: "I'll use the Task tool to launch the focused-coder agent to fix the lint errors in calendar.py" - User: "I need someone to refactor the database connection logic in storage/connection.py while I work on the API layer" Assistant: "I'll use the Task tool to launch the focused-coder agent to refactor the database connection logic in storage/connection.py" - After completing a feature: "Now I need to update the test fixtures in tests/fixtures/user_fixtures.py to support the new user role field" Assistant: "I'll use the Task tool to launch the focused-coder agent to update the test fixtures"

Use this agent when you need to make repetitive, mechanical changes across multiple files in the codebase, such as renaming functions, updating import statements, changing method signatures, removing deprecated parameters, or applying consistent formatting changes. This agent excels at identifying patterns and applying transformations systematically. Examples: - <example> Context: The user wants to rename a function across the entire codebase user: "Please rename all instances of getUserData() to fetchUserProfile()" assistant: "I'll use the mechanical-coder agent to efficiently rename this function across the codebase" <commentary> Since this is a mechanical change that needs to be applied consistently across multiple files, the mechanical-coder agent is perfect for this task. </commentary> </example> - <example> Context: The user needs to update deprecated API calls user: "We need to update all calls to the old API endpoint /api/v1/users to use /api/v2/users" assistant: "Let me use the mechanical-coder agent to update all API endpoint references" <commentary> This is a systematic change that requires finding and replacing patterns across the codebase, ideal for the mechanical-coder agent. </commentary> </example> - <example> Context: The user wants to add a new parameter to multiple function calls user: "Add a timeout=30 parameter to all requests.get() calls that don't already have one" assistant: "I'll use the mechanical-coder agent to add the timeout parameter where needed" <commentary> This requires pattern matching and conditional updates across files, which the mechanical-coder agent handles efficiently. </commentary> </example>

Use this agent when you need to perform repetitive, manual coding tasks across multiple files that cannot be automated with tools like ast-grep, sed, or other batch processors. This agent is designed to work in parallel with other instances, with each instance handling a single file. Examples include: <example> Context: User needs to update 15 component files to add a new lifecycle hook with custom logic that varies slightly per component. user: "I need to add ngOnInit to all these components and initialize their state based on their specific properties" assistant: "I'll use the Task tool to spawn multiple parallel-coder agents, one for each component file, to add the ngOnInit lifecycle hook with appropriate initialization logic." <commentary>Since this is a repetitive manual coding task across multiple files that can't be automated with search-replace tools, spawn parallel-coder agents to handle each file independently.</commentary> </example> <example> Context: User needs to refactor method signatures across multiple service files where each service has slightly different parameter requirements. user: "Update all these service methods to use the new error handling pattern, but each service needs different error types" assistant: "I'm going to use the Task tool to launch parallel-coder agents for each service file to update the error handling while preserving service-specific error types." <commentary>This requires manual coding judgment for each file, so use parallel-coder agents to work on files simultaneously.</commentary> </example> <example> Context: User is reviewing code and notices a pattern that needs fixing across many files. user: "All these test files are missing proper cleanup in afterEach - can you add the appropriate cleanup for each one?" assistant: "I'll use the Task tool to spawn parallel-coder agents to add proper cleanup logic to each test file's afterEach block." <commentary>Each test file needs different cleanup logic based on what's being tested, making this ideal for parallel-coder agents.</commentary> </example>

Use this agent when you need to test the appearance and functionality of web applications using Playwright automation tools. This agent should be used after implementing new features, fixing bugs, or making UI changes to verify that the application works correctly and looks as expected. Examples: <example>Context: The user has just implemented a new login form and wants to verify it works correctly. user: "I've just added a new login form to the application. Can you test that it displays properly and handles user input correctly?" assistant: "I'll use the playwright-qa-tester agent to thoroughly test the new login form functionality and appearance."</example> <example>Context: After fixing a bug in the navigation menu, the user wants to ensure the fix works and didn't break anything else. user: "I fixed the navigation menu bug. Please test that the menu works correctly now and check for any regressions." assistant: "Let me use the playwright-qa-tester agent to test the navigation menu fix and verify there are no regressions."</example>

Use this agent when encountering test failures, unexpected application behavior, performance issues, or other technical problems that require methodical investigation and root cause analysis. Examples: <example>Context: A test is failing intermittently and the user needs to understand why. user: "The test_calendar_sync test is failing about 30% of the time with a timeout error, but I can't figure out what's causing it" assistant: "I'll use the systematic-debugger agent to investigate this intermittent test failure methodically" <commentary>Since this involves debugging a tricky test failure that requires systematic investigation, use the systematic-debugger agent to analyze the problem methodically.</commentary></example> <example>Context: The application is behaving unexpectedly in production and needs investigation. user: "Users are reporting that their notes aren't being saved properly, but I can't reproduce it locally" assistant: "Let me use the systematic-debugger agent to investigate this production issue systematically" <commentary>This is a production behavior issue that requires methodical debugging to identify the root cause, perfect for the systematic-debugger agent.</commentary></example>

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.