outside-in-tdd
A TDD guide focusing on observable business behavior and inside-out design emergence for cleaner architecture.
Install
mkdir -p .claude/skills/outside-in-tdd && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/16648" && unzip -o skill.zip -d .claude/skills/outside-in-tdd && rm skill.zipInstalls to .claude/skills/outside-in-tdd
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Use when writing tests from the outside-in, defining behavior before code, or any feature where tests should start from observable business behavior and let internal design emergeKey capabilities
- →Map Gherkin scenarios to acceptance tests
- →Write acceptance tests with real domain objects
- →Let domain design emerge from failing tests
- →Verify with mutation testing
- →Write domain tests for business policies and rules
- →Mock only external boundaries in tests
How it works
The skill guides outside-in development by translating Gherkin scenarios into acceptance tests, allowing domain design to emerge from compilation failures, and verifying with mutation testing.
Inputs & outputs
When to use outside-in-tdd
- →Apply outside-in TDD
- →Map Gherkin scenario to acceptance tests
- →Drive domain design through failing tests
- →Mock external boundaries in tests
About outside-in-tdd
Promotes an outside-in testing methodology. It requires developers to start with Gherkin scenarios and write failing tests before creating domain classes, ensuring the design is driven strictly by requirements.
Use when writing tests from the outside-in, defining behavior before code, or any feature where tests should start from observable business behavior and let internal design emerge
When not to use it
- →When Gherkin scenarios are not written and approved
- →When creating domain classes before a test fails to compile
- →When mocking domain objects in acceptance tests
Limitations
- →The skill requires Gherkin scenarios to be written and approved
- →The skill emphasizes real domain objects and mocked external boundaries
- →The skill requires mutation testing for all changes
How it compares
This skill enforces an outside-in TDD approach where design emerges from failing tests and external boundaries are mocked, ensuring behavior-driven development unlike upfront design.
Compared to similar skills
outside-in-tdd side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| outside-in-tdd (this skill) | 0 | 4mo | No flags | Advanced |
| tdd-workflow | 6 | 4mo | Review | Intermediate |
| qlty-check | 5 | 7mo | Review | Beginner |
| superpowers-tdd | 5 | 7mo | No flags | Intermediate |
Try saying
Example prompts that trigger this skill in your AI assistant.
More by SebastienDegodez
View all by SebastienDegodez →You might also like
tdd-workflow
affaan-m
在编写新功能、修复错误或重构代码时使用此技能。强制执行测试驱动开发，包含单元测试、集成测试和端到端测试，覆盖率超过80%。
qlty-check
parcadei
Code quality checks, formatting, and metrics via qlty CLI
superpowers-tdd
anthonylee991
Applies tests-first discipline (red/green/refactor) and adds regression tests for bugs. Use when implementing features, fixing bugs, or refactoring.
solid
ramziddin
Use this skill when writing code, implementing features, refactoring, planning architecture, designing systems, reviewing code, or debugging. This skill transforms junior-level code into senior-engineer quality software through SOLID principles, TDD, clean code practices, and professional software design.
bunit-test-migration
FritzAndFriends
Migrate bUnit test files from deprecated beta API (1.0.0-beta-10) to bUnit 2.x stable API. Use this when working on .razor test files in BlazorWebFormsComponents.Test that contain old patterns like TestComponentBase, Fixture, or SnapshotTest.
code-refactor
luongnv89
Systematic code refactoring based on Martin Fowler's methodology. Use when users ask to refactor code, improve code structure, reduce technical debt, clean up legacy code, eliminate code smells, or improve code maintainability. This skill guides through a phased approach with research, planning, and safe incremental implementation.