testing-strategy

Plans test coverage using the red-green-refactor loop and test pyramid.

Updated Jul 10, 2026
One-click install
npx skills add https://github.com/Kaleb-Rupe/aurora --skill testing-strategy-kaleb-rupe
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: testing-strategy
Source: https://github.com/Kaleb-Rupe/aurora/tree/main/claude/skills/testing-strategy
Command: npx skills add https://github.com/Kaleb-Rupe/aurora --skill testing-strategy-kaleb-rupe

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Deciding what to test, at which level, and in what order is a recurring source of wasted effort: tests that never fail prove nothing, and coverage spent at the wrong pyramid level costs maintenance without catching defects. This Skill provides a disciplined test-first method for planning and writing tests. ## Core Features & Use Cases - Red-Green-Refactor Discipline: Enforces writing a failing test first, confirming it fails for the right reason, then implementing the minimal code to pass before refactoring. - Test Pyramid Guidance: Allocates tests across unit, integration, and end-to-end levels as a cost gradient, pushing tests down to the cheapest level that catches the same defect. - Coverage Planning: Produces a test plan naming what to cover (business-critical paths, error handling, edge cases, security boundaries, data integrity), what to skip, and explicit gaps in existing coverage. - Use Case: When starting a new feature, ask for a test-first plan and receive a behavior-by-behavior sequence of tests with the pyramid level for each, plus example cases. ## Quick Start Ask the assistant to plan a test-first strategy for the feature you are about to build, including pyramid levels and coverage gaps.

Frequently Asked Questions about testing-strategy

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I write tests test-first with red-green-refactor?

Write the smallest test for the next behavior and run it to confirm it fails for the expected reason. Then write the least code that makes it pass, and refactor only while the test bar is green, re-running to prove behavior held.

What is the test pyramid and how do I apply it?

The test pyramid allocates many fast unit tests, fewer integration tests at real boundaries like HTTP or databases, and a few end-to-end tests. Treat it as a cost gradient: push each test down to the cheapest level that catches the same defect.

What code should I cover with tests and what should I skip?

Cover business-critical paths, error handling, edge cases, security boundaries, and data integrity. Skip trivial getters, framework code, and one-off scripts, since tests there cost maintenance and catch nothing.

Why is a test that never failed considered worthless?

A test that has never failed proves nothing because it may assert nothing or only cover code that already existed. Watching a test fail for the right reason confirms it actually exercises the intended behavior.

When should I choose integration tests over unit tests?

Choose integration tests when the defect only appears at a real boundary, such as an HTTP call, a database, or an actual process. Otherwise prefer unit tests, since they run faster and catch the same logic defects at lower cost.