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

Execute a refactor safely with tests staying green

Review implementation was faithfully executed

Refine bd task requirements with SRE-level edge-case analysis

Create detailed implementation plan with bite-sized tasks

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 to audit test quality with Google Fellow SRE scrutiny - identifies tautological tests, coverage gaming, weak assertions, missing corner cases. Creates bd 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 bd 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

Use when facing 3+ independent failures that can be investigated without shared state or dependencies - dispatches multiple Claude agents to investigate and fix independent problems concurrently

Use to execute bd tasks iteratively - executes one task, reviews learnings, creates/refines next task, then STOPS for user review before continuing

Use when implementation complete and tests pass - closes bd epic, presents integration options (merge/PR/keep/discard), executes choice

Use when encountering a bug - complete workflow from discovery through debugging, bd issue, test-driven fix, verification, and closure

Use for advanced bd operations - splitting tasks mid-flight, merging duplicates, changing dependencies, archiving epics, querying metrics, cross-epic dependencies

Use when designing a refactor after diagnosis - selects patterns, defines composition and DI seams, and produces a test-ready refactor design spec

Use when identifying bad code/design and selecting refactor targets - produces a diagnosis report with smells, risks, and refactor vs rewrite decision

Use when refactoring code - test-preserving transformations in small steps, running tests between each change

Use after hyperpowers:executing-plans completes all tasks - verifies implementation against bd spec, all success criteria met, anti-patterns avoided

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

Use when skills aren't activating reliably - covers official solutions (better descriptions) and custom hook system for deterministic skill activation

Use when you have to refine subtasks into actionable plans ensuring that all corner cases are handled and we understand all the requirements.

Use when implementing features or fixing bugs - enforces RED-GREEN-REFACTOR cycle requiring tests to fail before writing code

Use when writing or changing tests, adding mocks - prevents testing mock behavior, production pollution with test-only methods, and mocking without understanding dependencies

Use when starting any conversation - establishes mandatory workflows for finding and using skills

Use before claiming work complete, fixed, or passing - requires running verification commands and confirming output; evidence before assertions always

Use to expand bd tasks with detailed implementation steps - adds exact file paths, complete code, verification commands assuming zero context

Use when creating new skills, editing existing skills, or verifying skills work - applies TDD to documentation by testing with subagents before writing

9 hooks across 5 events