dotfiles-dev-tools

Use this agent when you have failing tests and need to write the minimal code necessary to make them pass. This agent should be used after writing tests or using the red-phase-tester agent, when you're ready to move from red to green in the TDD cycle. Examples: <example>Context: User has written tests for a new feature and they are currently failing. user: 'I've written tests for a user authentication function, but they're all failing. Here are the test cases...' assistant: 'I'll use the green-phase-implementer agent to write the minimal code needed to make these tests pass.' <commentary>The user has failing tests and needs implementation code, which is exactly when to use the green-phase-implementer agent.</commentary></example> <example>Context: User just used the red-phase-tester agent and now has failing tests. user: 'The red-phase tests are complete and failing as expected. Now I need to implement the actual functionality.' assistant: 'Perfect! Now I'll use the green-phase-implementer agent to write the minimal implementation that makes these tests pass.' <commentary>This is the natural progression from red phase to green phase in TDD.</commentary></example>

Use this agent when you need to generate failing tests for the red phase of TDD before implementing any new functionality. This agent should be used proactively whenever you're about to write new code, add features, fix bugs, or refactor existing functionality. Examples: <example>Context: User is about to implement a new authentication system. user: 'I need to create a user login function that validates email and password' assistant: 'Let me use the red-phase-tester agent to generate the failing tests first before we implement the login functionality' <commentary>Since the user is about to write new code, use the red-phase-tester agent to create failing tests that define the expected behavior before implementation.</commentary></example> <example>Context: User is working on a bug fix for a payment processing function. user: 'The payment processor isn't handling declined cards properly' assistant: 'I'll use the red-phase-tester agent to create tests that capture the expected behavior for declined card handling' <commentary>Before fixing the bug, use the red-phase-tester agent to write tests that define how declined cards should be handled.</commentary></example>

Specialized in finding security vulnerabilities in code.

Use this agent when you have just completed the green phase of TDD (making tests pass) and need to refactor the implementation code. This agent should be called after you've successfully implemented functionality to make tests pass and want to improve code quality without changing behavior. Examples: <example>Context: User has just implemented a function to make their tests pass and wants to clean up the code. user: 'I just got my tests passing for the user authentication feature. The code works but it's messy.' assistant: 'Let me use the tdd-refactor-specialist agent to help clean up your authentication code while keeping the tests green.' <commentary>Since the user completed the green phase and needs refactoring, use the tdd-refactor-specialist agent.</commentary></example> <example>Context: User mentions they finished implementing a feature and tests are passing. user: 'All my tests are green now for the payment processing module. Time to clean things up.' assistant: 'I'll use the tdd-refactor-specialist agent to help refactor your payment processing code.' <commentary>The user has completed green phase and is ready for refactoring, so use the tdd-refactor-specialist agent.</commentary></example>

Use this agent proactively after the refactor phase of TDD cycles to verify implementation completeness and quality. Examples: <example>Context: User has just completed a refactor phase in TDD and wants to ensure all tests are properly implemented. user: 'I just finished refactoring the user authentication module' assistant: 'Let me use the tdd-review-agent to check for any unimplemented tests or unnecessary mocks in your refactored code' <commentary>Since the user completed a refactor phase, proactively use the tdd-review-agent to review the implementation for completeness and quality issues.</commentary></example> <example>Context: Green and refactor phases are complete for a feature. user: 'The payment processing feature is now refactored and all tests are passing' assistant: 'I'll run the tdd-review-agent to verify the implementation is complete and identify any remaining work' <commentary>After refactor phase completion, use the tdd-review-agent to ensure no tests are skipped and mocks are appropriate.</commentary></example>

4 hooks across 1 event

gopls