Test strategy

Skill yuri-semenenko/ai-engineering-workspace/codex/skills/test-strategy

One engineering workflow across Claude Code, Codex, Copilot, and Gemini CLI. A portable persona canon, process skills, and safety guardrails, kept in sync by design.

Install

npx -y skills add yuri-semenenko/ai-engineering-workspace --skill test-strategy

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

0 stars0 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Use when writing or reviewing tests, deciding coverage for a change, driving new code test-first, or fixing a bug that needs a regression test. Covers what to test, the TDD loop, and failing-test-first.

SKILL.md

1.8 KB, as published. Nobody here has run it

Test Strategy

Tests are the executable spec. Optimize them for reading and for meaningful assertions, not for coverage numbers.

What to test

Branch logic, boundaries, contracts, and error paths first.
Skip trivial pass-throughs, framework internals, and implementation details.
Test through the public surface, not private state or call order.

TDD loop (new behavior)

Agree the seam where the test attaches before writing it.
Red: write one failing test for the next thin slice; watch it fail for the intended reason.
Green: write the least code that makes it pass.
Refactor as a separate step, with the test green as the safety net.

Slice vertically (one thin path through every layer), not horizontally. One slice at a time.

Bug-fix protocol

Write the regression test that reproduces the bug; it must fail for the reported reason.
Fix; the test goes green.
Run the surrounding suite so the fix did not move the bug elsewhere.

Guardrails

DAMP over DRY: the failing output alone should say what broke.
Deterministic only: no real time, no real network, no order dependence, no logic inside a test.
Keep the pyramid: mostly unit, integration at real seams, few end-to-end.
If a test is impossible (non-deterministic or environment-bound), say so plainly rather than implying coverage.
Delegate mechanical scaffolding (boilerplate, fixtures, codemods) to a cheaper-tier subagent; keep the seam choice and the "is the behavior actually covered" judgment on the main model. A green suite is evidence, not proof.