Testing & TDD Skills for AI Coding Agents

Best for: TDD that produces tests worth keeping, not just green ones

This skill treats TDD as a structured specification technique rather than just a code loop. Its core principle is establishing explicit seams, public interfaces where tests verify behavior without binding to internal details. Before writing any test, the agent must define and confirm these seams with you so effort focuses on critical contracts.

It explicitly calls out anti-patterns like implementation-coupled tests, tautological tests that duplicate production logic, and horizontal slicing. Instead, it enforces vertical tracer-bullet slices executed one step at a time.

• 766K installs, primary reference for quality test boundaries
• Requires pre-agreed seams before test authoring begins
• Flags tautological and implementation-bound test traps
• Enforces tracer-bullet vertical slices per cycle

Best for: Agents that attempt to bypass writing tests first

Written to enforce strict compliance, this skill centers on an absolute rule: write no production code until a failing test is in place. If an agent writes implementation code before a test, it must delete that code and restart the cycle.

It features a rationalizations table addressing common agent excuses such as code being too simple or deletion being wasteful. Mandatory verify-red and verify-green steps ensure the test actually observed failure before passing.

• Iron Law: failing test first with zero exceptions
• Enforces deletion of premature implementation code
• Rationalization lookup table counters common agent excuses
• Mandatory verify-red and verify-green execution steps

Best for: Establishing test scope and expectations before writing code

This skill guides initial test planning by matching strategy to architecture. API components receive unit, integration, and contract tests, while data pipelines target idempotency and transformations.

It includes explicit skip guidelines to avoid low-value tests on trivial getters or framework boilerplate. The output is a structured test plan outlining required coverage levels.

• Component-specific strategy mapping
• Defines explicit skip rules to eliminate test busywork
• Outputs actionable test plans with coverage goals
• Pairs with active TDD drivers during implementation

Best for: Conditional use when intentionally configuring a mewt or muton campaign

This skill is conditional only when intentionally configuring a mewt or muton mutation-testing campaign. It configures fault-injection runs to evaluate campaign resilience, with muton providing sibling support for TON smart contracts.

It is not a general test-quality, release, or generic coverage tool. Its work is strictly campaign engineering: scoping targets file by file, tuning timeouts, and structuring two-phase runs for mewt or muton.

• Conditional for mewt and muton campaign configuration
• Not for general test-quality or generic coverage audits
• Scopes targets file by file and tunes timeouts
• Covers Rust, Go, Solidity, TypeScript, and JavaScript

Best for: Reviewing a test suite for brittle or misleading patterns

This skill helps identify testing anti-patterns that make suites brittle, misleading, or difficult to maintain.

Use it during test review to replace low-signal checks with tests that better reflect intended behavior.

• Surfaces brittle and misleading test patterns
• Supports behavior-focused test review
• Improves confidence without adding low-signal checks

Best for: Writing or reviewing tests for Bash scripts and command-line behavior

This skill provides Bats testing patterns for structuring Bash tests around observable command-line behavior.

Use it to make shell test setup, assertions, and failure diagnostics consistent across a script suite.

• Patterns tailored to Bats and Bash tests
• Focuses assertions on observable shell behavior
• Improves setup and failure diagnostics

Best for: Testing Vue components and application behavior with less coupling

This skill guides testing Vue components and application behavior with practices that keep tests focused on user-visible contracts.

Use it when adding or reviewing Vue tests to avoid coupling assertions to implementation details.

• Guidance specific to Vue testing workflows
• Centers tests on observable component behavior
• Reduces implementation-coupled assertions

Best for: Preparing generated mocks for Dart unit and interaction tests

This skill guides the Dart workflow for generating test mocks from the interfaces a test needs to substitute.

Use it to keep generated mock artifacts aligned with source changes before running the relevant tests.

• Workflow for generated Dart test mocks
• Keeps mocks aligned with source interfaces
• Supports unit and interaction-test setup

Best for: Writing E2E tests, debugging flaky tests, or establishing browser-test standards

e2e-testing-patterns is a general end-to-end testing workflow for Playwright and Cypress. It covers reliable suite design, fixtures, isolation, network mocking, and page-object boundaries without tying the guide to one interactive vendor session tool.

Use it when implementing E2E tests, diagnosing flaky browser checks, or setting team-wide browser-test standards. It complements focused component testing and should be selected when the behavior crosses a real user journey.

• Playwright and Cypress end-to-end test patterns
• Fixtures, test isolation, and network mocking
• Page-object boundaries and reliable selectors
• Flaky-test diagnosis and suite standards