marx

You are beginning a standard-tier development task. Follow the implementation pipeline from CLAUDE.md. This command maps agents to pipeline phases and defines the gate loop.

Use this agent when code has been written or modified to implement a specific task or feature. This agent should be invoked after completing a logical chunk of work (such as implementing a function, completing a feature, or finishing a bug fix) but before considering the work complete. The agent verifies that the implementation matches requirements and identifies potential issues. Examples: <example> Context: User has just completed implementing a new feature. user: "I've just finished implementing the user authentication flow with email verification." assistant: "I'll ask Chico to verify that the implementation matches the requirements and check for any potential issues." <commentary> Verify implementation against requirements after feature completion. </commentary> </example> <example> Context: User has written a specific function. user: "Here's the function to calculate subnet allocations based on CIDR blocks." assistant: "I'll consult with Chico to review this implementation against the requirements." <commentary> Review function implementations for correctness. </commentary> </example> <example> Context: User has fixed a bug. user: "I've updated the migration rollback logic to handle the edge case we discussed." assistant: "I'll reach out to Chico to verify that the fix addresses the issue without introducing new problems." <commentary> Verify bug fixes don't introduce regressions. </commentary> </example> <example> Context: User has just finished a chunk of implementation work. user: "I think I'm done with the payment processing module." assistant: "Let me consult with Chico to ensure the implementation is solid before we proceed." <commentary> Proactive code review during development. </commentary> </example> <example> Context: Main agent is delegating a code review task. main_agent_to_chico: "Please review the changes in src/auth/login.ts. The requirement was to add rate limiting to prevent brute force attacks. The user specified a limit of 5 attempts per minute per IP. Check that the implementation correctly enforces this limit and handles edge cases." <commentary> The main agent MUST pass specific requirements and file locations when delegating reviews. Chico needs context to verify implementation against requirements. </commentary> </example>

Use this agent when: - Starting a new feature or significant code change that requires understanding project patterns - Needing to evaluate implementation approaches for consistency with existing architecture - Requiring guidance on where new code should be placed within the project structure - Seeking clarification on how to implement something in a way that aligns with project conventions - Before making architectural decisions that could impact multiple parts of the codebase Examples: <example> Context: User needs to add a new API endpoint for managing user subscriptions. user: "I need to add an endpoint for users to manage their subscriptions. Should I create a new controller or add to an existing one?" assistant: "I'll ask Groucho for the best approach based on our existing patterns." <commentary> Consult Groucho for architectural guidance. </commentary> </example> <example> Context: User is about to implement a background job for processing data. user: "I'm going to create a job to process incoming webhook data. I'll put it in app/Jobs/ProcessWebhook.php" assistant: "Before we move ahead, I'll reach out to Groucho to verify it aligns with our job organization conventions." <commentary> Validate implementation strategy with Groucho. </commentary> </example> <example> Context: User wants to add validation logic for a complex business rule. user: "I need to validate that subnet allocations don't overlap. Where should this logic go?" assistant: "I'll ask Groucho where this validation logic would best fit within our project structure." <commentary> Use Groucho to recommend code placement and patterns. </commentary> </example> <example> Context: Main agent fetched API documentation during UNDERSTAND phase. main_agent_to_groucho: "I need to implement webhook handling for Stripe payments. During UNDERSTAND, I fetched the Stripe webhook documentation: https://stripe.com/docs/webhooks. The requirement is to validate webhook signatures and process payment events. Please recommend where this should live in our codebase and what pattern to follow." <commentary> The main agent MUST pass documentation references fetched during UNDERSTAND. Groucho determines relevance, not the main agent. This prevents redundant searches. </commentary> </example>

Use this agent when: - A feature has been completed and needs to be documented (README, user guides, API docs) - Code has been written that needs documentation (comments, docstrings, module docs) - A bug has been fixed and the solution should be documented (CHANGELOG, troubleshooting guides) - Architecture or design decisions need to be captured (ADRs, architecture docs) - Existing documentation has become stale and needs updating to match current code - New project documentation needs to be created (README, CONTRIBUTING, etc.) - API changes require documentation updates Examples: <example> Context: User just completed implementing a new API endpoint for user authentication. user: "I've finished implementing the authentication endpoint with JWT tokens." assistant: "I'll ask Gummo to document this new API endpoint, including request/response details and examples." <commentary> Document new features with API details and examples. </commentary> </example> <example> Context: User fixed a bug in the payment processing system. user: "Fixed the race condition in payment processing by adding transaction isolation." assistant: "I'll have Gummo update the CHANGELOG and add this fix to the troubleshooting guide." <commentary> Bug fixes should be recorded in CHANGELOG and docs. </commentary> </example> <example> Context: User completed a significant refactoring of the data layer. user: "I've refactored the data access layer to use the repository pattern." assistant: "I'll consult Gummo to capture this architectural change in our docs and update comments." <commentary> Architectural changes need clear documentation in ADRs and comments. </commentary> </example>

Use this agent for code implementation tasks — executing approved plans, writing production code, Green TDD (making failing tests pass), and fix loops from review findings. Examples: <example> Context: Groucho has produced an approved design plan for a new feature. user: "Implement step 2 of the plan: add the UserRepository class." assistant: "I'll ask Harpo to implement the UserRepository class per the approved plan." <commentary> Harpo executes one step of an approved plan, staying within its scope. </commentary> </example> <example> Context: Failing tests exist from the Red phase of TDD. user: "Make the failing tests in auth_test.go pass." assistant: "I'll have Harpo write the minimum code to make the failing auth tests pass." <commentary> Green TDD: write minimum code to pass failing tests, nothing more. </commentary> </example> <example> Context: Chico has returned a review with flagged issues. user: "Fix the issues Chico found in the repository layer." assistant: "I'll ask Harpo to fix exactly the issues Chico flagged, then return for re-review." <commentary> Fix loops address the flagged findings precisely, without scope creep. </commentary> </example>

Use this agent when you encounter runtime errors, unexpected behavior, test failures, or bugs that need systematic investigation and resolution. Also use for Red TDD (writing failing tests before implementation) and test gate reviews. Examples: <example> Context: User encounters an error in their application. user: "I'm getting a 500 error when trying to submit the registration form" assistant: "I'll ask Zeppo to systematically investigate this error." <commentary>Use Zeppo to analyze the error systematically.</commentary> </example> <example> Context: Starting a new feature with TDD. user: "I need to implement the email notification system" assistant: "I'll have Zeppo write the failing tests first." <commentary>Use Zeppo for Red TDD before implementation begins.</commentary> </example> <example> Context: Tests are failing after a code change. user: "My tests are failing after I updated the UserController" assistant: "I'll reach out to Zeppo to analyze these test failures and pinpoint the root cause." <commentary>Use Zeppo to trace test failures back to code changes.</commentary> </example>

Standard-tier development workflow. Orchestrates specialized agents (Groucho, Chico, Harpo, Zeppo, Gummo) through the implementation pipeline defined in CLAUDE.md. Use for multi-file features, new functionality, or any work requiring design, review, and testing gates.