tdd-implementation-audit

Audit TDD implementations against design.md and detailed-design.md.

4|1|Updated Apr 8, 2026
One-click install
npx skills add https://github.com/CurtisThe/three-pillars-plugin --skill tdd-implementation-audit
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tdd-implementation-audit
Source: https://github.com/CurtisThe/three-pillars-plugin/tree/main/skills/tdd-implementation-audit
Command: npx skills add https://github.com/CurtisThe/three-pillars-plugin --skill tdd-implementation-audit

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Final audits ensure a completed TDD design implementation aligns with both design.md and detailed-design.md, identifying drift, gaps, and unintended additions after all phases are finished.

Core Features & Use Cases

  • Preflight: load and verify all design artifacts from docs/tdd-designs to prepare for the implementation audit.
  • Scope verification: ensure every in-scope item from design.md is implemented with correct relationships, constraints, and behaviors.
  • Interface fidelity: check module structure, public APIs, and data flow against detailed-design.md.
  • Test validation: confirm the test Strategy and coverage described in the design are implemented.
  • Drift detection: identify deviations between phases and ensure consistency across design artifacts and code.
  • Documentation: generate an implementation-audit.md artifact summarizing findings, gaps, and recommendations.

Quick Start

Run the audit for a design by providing its name, e.g., tdd-implementation-audit <design-name> [--force-takeover].

Frequently Asked Questions about tdd-implementation-audit

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

FAQPage Schema
How do I audit my code for drift against TDD design documents?

To audit code for TDD design drift, you verify completed implementations against design.md and detailed-design.md. This process checks scope coverage, interface fidelity, and test strategy alignment, ultimately generating an implementation-audit.md artifact that highlights gaps and deviations across all project phases.

What is the best way to verify implementation fidelity after completing all TDD phases?

The best way to verify implementation fidelity is by running a comprehensive end-to-end audit across your docs/tdd-designs directory. This checks that module structures, public APIs, and data flow match the detailed design, detecting any unintended additions or behavioral drift that occurred during phased development.

Can I check if my test coverage matches the strategy defined in my TDD design docs?

Yes, you can validate your test strategy by auditing the completed implementation against the design artifacts. The audit specifically confirms whether the test coverage and strategies described in your design documents were actually implemented and executed across the codebase.

How do I generate a gap analysis report for my completed software implementation?

You generate a gap analysis report by auditing the final codebase against your design specifications. The audit examines scope, interfaces, and tests to identify missing items and deviations, automatically producing an implementation-audit.md artifact summarizing all findings and recommendations.

Does a TDD implementation audit work with design files stored in the docs/tdd-designs folder?

Yes, the audit specifically targets designs stored under the docs/tdd-designs directory. It loads and verifies these design artifacts during a preflight phase to prepare for a comprehensive scope and interface fidelity check across the entire project.