tdd
๐ฏSkillfrom mattpocock/skills
|Enforces test-driven development with a strict red-green-refactor loop using vertical slices (one test then one implementation at a time), emphasizing behavior verification through public interfaces rather than implementation-coupled testing.
Overview
A Claude Code skill by Matt Pocock that teaches test-driven development using the red-green-refactor loop with a focus on integration-style tests that verify behavior through public interfaces. It emphasizes vertical slicing (one test then one implementation at a time) over horizontal slicing, and ensures tests survive refactoring by testing what the system does rather than how it does it.
Key Features
- Red-Green-Refactor Workflow - Structured TDD loop with planning, behavior-first test writing, implementation, and refactoring phases
- Vertical Slice Approach - Enforces one test followed by one implementation per cycle, preventing the anti-pattern of writing all tests before all implementation
- Behavior-Based Testing - Tests exercise real code paths through public APIs rather than mocking internal collaborators or testing private methods
- Structured Planning Phase - Requires confirming interfaces, identifying testable behaviors, designing for testability, and getting user approval before coding
- Deep Module Design - Incorporates the concept of small interfaces with deep implementations for better testability and maintainability
Who is this for?
This skill is designed for developers who want to adopt or improve their test-driven development practices with a focus on writing meaningful integration-style tests. It is particularly valuable for teams that have experienced test suites that break during refactoring due to implementation coupling, and who want a structured methodology for building features test-first.
Same repository
mattpocock/skills(54 items)
Installation
npx vibeindex add mattpocock/skills --skill tddnpx skills add mattpocock/skills --skill tdd~/.claude/skills/tdd/SKILL.mdSKILL.md
More from this repository10
Interviews the user relentlessly about every aspect of a plan or design until reaching shared understanding, resolving each branch of the decision tree one by one. Provides recommended answers for each question and explores the codebase when answers can be found there.
A skill that runs a grilling session to challenge your plan against an existing domain model, sharpen terminology by building a shared language in CONTEXT.md, and document architectural decisions in ADRs before coding begins.
An agent skill from Matt Pocock's engineering toolkit that helps improve your codebase architecture. Part of a composable skill set designed to fix common AI coding agent failure modes through structured, experience-based workflows.
Initial setup skill for Matt Pocock's engineering skills collection that configures your backlog manager, triage labels, and documentation paths for AI coding agents.
A composable skill for triaging issues and tickets using configurable labels, designed to fix common failure modes in AI coding agents by providing structured backlog management workflows.
A collection of small, composable engineering skills designed for real development workflows, featuring grilling sessions for requirement alignment, issue tracking integration, and task triage with customizable labels.
A skill that turns the current conversation context and codebase understanding into a structured PRD (Product Requirements Document) and submits it as a GitHub issue, with modular architecture and user story generation.
Breaks a plan, spec, or PRD into independently-grabbable GitHub issues using tracer-bullet vertical slices. Each issue is a thin end-to-end path through every integration layer that can be demoed or verified on its own.
Composable, model-agnostic agent skills for real engineering workflows, featuring /grill-me for requirement alignment, /prototype for rapid iteration, and task management tools designed to fix common failure modes in AI coding agents.
A collection of composable engineering skills by Matt Pocock designed to fix common AI coding agent failure modes: misalignment via grilling sessions, verbosity through shared domain language (CONTEXT.md), code quality with TDD red-green-refactor loops, and codebase entropy with architecture improvement workflows.