hyperpowers

Audit test quality - identify tautological tests, coverage gaming, missing corner cases

Interactive design refinement using Socratic method

Execute plan in batches with review checkpoints

Design a refactor with composition, DI, and test strategy

Diagnose code/design smells and refactor targets

Use this agent when a major project step has been completed and needs to be reviewed against the original plan and coding standards. Examples: <example>Context: The user is creating a code-review agent that should be called after a logical chunk of code is written. user: "I've finished implementing the user authentication system as outlined in step 3 of our plan" assistant: "Great work! Now let me use the hyperpowers:code-reviewer agent to review the implementation against our plan and coding standards" <commentary>Since a major project step has been completed, use the hyperpowers:code-reviewer agent to validate the work against the plan and identify any issues.</commentary></example> <example>Context: User has completed a significant feature implementation. user: "The API endpoints for the task management system are now complete - that covers step 2 from our architecture document" assistant: "Excellent! Let me have the hyperpowers:code-reviewer agent examine this implementation to ensure it aligns with our plan and follows best practices" <commentary>A numbered step from the planning document has been completed, so the hyperpowers:code-reviewer agent should review the work.</commentary></example>

Use this agent when planning or designing features and you need to understand current codebase state, find existing patterns, or verify assumptions about what exists. Examples: <example>Context: Starting brainstorming phase and need to understand current authentication implementation. user: "I want to add OAuth support to our app" assistant: "Let me use the hyperpowers:codebase-investigator agent to understand how authentication currently works before we design the OAuth integration" <commentary>Before designing new features, investigate existing patterns to ensure the design builds on what's already there.</commentary></example> <example>Context: Writing implementation plan and need to verify file locations and current structure. user: "Create a plan for adding user profiles" assistant: "I'll use the hyperpowers:codebase-investigator agent to verify the current user model structure and find where user-related code lives" <commentary>Investigation prevents hallucinating file paths or assuming structure that doesn't exist.</commentary></example>

Use this agent when planning or designing features and you need current information from the internet, API documentation, library usage patterns, or external knowledge. Examples: <example>Context: Designing integration with external service and need to understand current API. user: "I want to integrate with the Stripe API for payments" assistant: "Let me use the hyperpowers:internet-researcher agent to find the current Stripe API documentation and best practices for integration" <commentary>Before designing integrations, research current API state to ensure plan matches reality.</commentary></example> <example>Context: Evaluating technology choices for implementation plan. user: "Should we use library X or Y for this feature?" assistant: "I'll use the hyperpowers:internet-researcher agent to research both libraries' current status, features, and community recommendations" <commentary>Research helps make informed technology decisions based on current information.</commentary></example>

Use this agent to analyze test effectiveness with Google Fellow SRE-level scrutiny. Identifies tautological tests, coverage gaming, weak assertions, and missing corner cases. Returns actionable plan to remove bad tests, strengthen weak ones, and add missing coverage. Examples: <example>Context: User wants to review test quality in their codebase. user: "Analyze the tests in src/auth/ for effectiveness" assistant: "I'll use the test-effectiveness-analyst agent to analyze your auth tests with expert scrutiny" <commentary>The agent will identify meaningless tests, weak assertions, and missing corner cases, returning a prioritized improvement plan.</commentary></example> <example>Context: User suspects tests are gaming coverage. user: "Our coverage is 90% but we keep finding bugs in production" assistant: "This suggests coverage gaming. Let me use the test-effectiveness-analyst agent to audit test quality" <commentary>High coverage with production bugs indicates tautological or weak tests that the agent will identify.</commentary></example>

Use this agent to run tests, pre-commit hooks, or commits without polluting your context with verbose output. Agent runs commands, captures all output in its own context, and returns only summary + failures. Examples: <example>Context: Implementing a feature and need to verify tests pass. user: "Run the test suite to verify everything still works" assistant: "Let me use the test-runner agent to run tests and report only failures" <commentary>Running tests through agent keeps successful test output out of your context.</commentary></example> <example>Context: Before committing, need to run pre-commit hooks. user: "Run pre-commit hooks to verify code quality" assistant: "I'll use the test-runner agent to run pre-commit hooks and report only issues" <commentary>Pre-commit hooks often generate verbose formatting output that pollutes context.</commentary></example> <example>Context: Ready to commit, want to verify hooks pass. user: "Commit these changes and verify hooks pass" assistant: "I'll use the test-runner agent to run git commit and report hook results" <commentary>Commit triggers pre-commit hooks with lots of output.</commentary></example>

Use when errors occur deep in execution - traces bugs backward through call stack to find original trigger, not just symptom

Use to audit test quality with Google Fellow SRE scrutiny - identifies tautological tests, coverage gaming, weak assertions, missing corner cases. Creates br epic with tasks for improvements, then runs SRE task refinement on each.

Use when creating or developing anything, before writing code - refines rough ideas into br epics with immutable requirements

Use when creating Claude Code hooks - covers hook patterns, composition, testing, progressive enhancement from simple to advanced

Use when encountering bugs or test failures - systematic debugging using debuggers, internet research, and agents to find root cause before fixing

9 hooks across 5 events