Skip to main content
skill CX Codex

054-design-tdd — skill for Claude Code: TDD workflow for Java

054-design-tdd — a skill that walks Java developers through red-green-refactor cycles with test-driven development. Write a failing test first, implement just enough code to pass, then refactor while tests stay green.

Apache-2.0 177 installs ★ 465 updated 2026-10-21

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add jabrena/plinth --skill 054-design-tdd -a claude-code
Open on GitHub

What 054-design-tdd does

This is more than a suggestion to write tests. The skill maintains a list of candidate test cases, helps you pick the next behavior to implement, requires a failing test before production code, and verifies each cycle passes. Once a test is green, you refactor—rename, remove duplication, reorganize—without breaking anything.

The cycle has five stages: build the test list, select one behavior, write a failing test, implement minimal code, then refactor. The skill enforces that you don't jump into speculative branches or start cleaning up before the current test passes. At the end of each cycle, it reports what passed, what was skipped, and what risks remain.

What it helps with

  • Ensure code is tested before refactoring begins
  • Decide which behavior to test next in a complex feature
  • Surface edge cases and error paths in a Java method
  • Verify the public API contract before consumers call it
  • Track which checks are still missing

Example prompts for the agent

  • Apply TDD to this method
  • Walk this function through red-green-refactor
  • Write a failing test for error handling, then the code

How to install 054-design-tdd

1Skills CLI (Vercel)

npx skills add jabrena/plinth --skill 054-design-tdd -a claude-code

2Manually: put the files in place

~/.claude/skills/054-design-tdd/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/054-design-tdd/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about 054-design-tdd

How do I install 054-design-tdd in Claude Code?

Run npx skills add jabrena/plinth --skill 054-design-tdd -a claude-code, then open ~/.claude/skills/054-design-tdd/SKILL.md.

What does 054-design-tdd do?

It guides Java development through TDD: manage test lists, select behavior, write failing tests first, implement minimal code, refactor. Reports missing coverage and remaining risks.

Do I need to set anything up before using this skill?

The skill reads references/054-design-tdd.md on first use—it contains detailed examples, constraints, and workflow steps.

Source text

SKILL.md · Apache-2.0
---
name: 054-design-tdd
description: Use when Java implementation work should be guided by Test-Driven Development, including maintaining a test list, choosing the next behavior, writing a failing test first, implementing only enough production code to pass, and refactoring while keeping tests green. This should trigger for requests such as Apply TDD; Use test-driven development; Drive this Java change with tests; Write the failing test first; Red-green-refactor this feature. Part of Plinth Toolkit
license: Apache-2.0
metadata:
  author: Juan Antonio Breña Moral
  version: 0.19.0
---
# Test-Driven Development Design

Guide Java developers through Test-Driven Development for implementation work. **This is an interactive SKILL**.

**What is covered in this Skill?**

- Maintaining or refining a list of candidate test cases
- Selecting the next useful behavior or test case before editing production code
- Writing a failing test first to clarify the public interface, API shape, or usage of the code
- Writing only enough functional production code to pass the selected test
- Refactoring new and existing code while tests remain green
- Adding newly discovered test cases to the list without losing the current TDD cycle
- Reporting skipped checks, missing tests, and remaining risks when verification is incomplete

## Constraints

Keep implementation work inside the red-green-refactor cycle, with one selected behavior driving each small change.

- **MUST** read `references/054-design-tdd.md` before applying TDD guidance
- **MUST** maintain or refine a test list when more than one behavior, edge case, or question is in scope
- **MUST** select the next useful behavior or test case before writing production code
- **MUST** write or describe the failing test first and use it to clarify the public interface or usage
- **MUST** implement only the functional production code needed to pass the selected failing test
- **MUST** refactor new and existing code only after the selected test passes and while keeping tests green
- **MUST** report skipped checks, missing tests, and remaining risks when verification is incomplete

## When to use this skill

- Apply TDD
- Use test-driven development
- Drive this Java change with tests
- Write the failing test first
- Red-green-refactor this feature
- Build this behavior test first

## Workflow

1. **Build the Test List**

Read `references/054-design-tdd.md`, then list candidate behaviors, edge cases, error paths, integration boundaries, and design questions that may need tests. Add newly discovered cases to the list as work proceeds.

2. **Select the Next Behavior**

Choose the next useful test case: small enough to implement in one cycle, valuable enough to move the design forward, and specific enough to expose the expected observable outcome.

3. **Write the Failing Test First**

Write or describe the failing unit, integration, acceptance, or characterization test before production code. Use the test to clarify the public interface, API shape, inputs, outputs, errors, or usage of the code.

4. **Make the Test Pass**

Implement the smallest functional production code needed to pass the selected test. Avoid speculative branches, abstractions, framework wiring, or cleanup that is not required by the current failing test.

5. **Refactor While Green**

After the selected test passes, refactor new and existing code to improve names, duplication, responsibility placement, type design, and test clarity while keeping the relevant tests green.

6. **Report and Continue**

Report the selected behavior, failing-test-first signal, code added to pass, refactoring performed, verification results, skipped checks, missing tests, and remaining risks. Return to the test list for the next cycle.

## Reference

For detailed guidance, examples, and constraints, see [references/054-design-tdd.md](references/054-design-tdd.md).

© Juan Antonio Breña Moral · Apache-2.0 · jabrena/plinth

Similar skills

All skills for Testing and QA →

From the same set123

The whole set →
801-regulations-eu-ai-act 801-regulations-eu-ai-act helps Java teams apply EU AI Act engineering controls to enterprise applications using LLMs, RAG, and AI agents before production deployment. CX Codex +1 212installs 805-regulations-eu-cyber-resilience-act The 805-regulations-eu-cyber-resilience-act skill reviews Java products and related components for engineering work tied to the EU Cyber Resilience Act. Use it when assessing a change or preparing a release. CX Codex +1 212installs 806-regulations-eu-data-act 806-regulations-eu-data-act is a Claude Code skill that checks Java services, APIs, and pipelines for EU Data Act controls before a data-sharing feature ships. CX Codex +1 212installs 500-frameworks-micronaut-create-project The 500-frameworks-micronaut-create-project skill scaffolds a Micronaut 4.x Maven project with SDKMAN-managed tools and checks the generated build. Use it when starting a Micronaut service. CX Codex +1 211installs 707-technologies-hexagonal-architecture 707-technologies-hexagonal-architecture is a Claude Code skill that reviews and improves Hexagonal architecture boundaries in Java projects without coupling to Spring Boot, Quarkus, or Micronaut. CX Codex +1 174installs 056-design-avoid-breaking-changes 056-design-avoid-breaking-changes reviews plans, OpenSpec changes, and APIs for breaking changes and migration risks before release. CX Codex +1 172installs 055-design-parallel-change The 055-design-parallel-change skill guides you through designing safe database schema changes when old and new application versions must run simultaneously. It breaks complex migrations into three separately deployable phases. CX Codex +1 172installs 052-design-hamburger-method 052-design-hamburger-method splits oversized user stories and specs into thin vertical slices using the Hamburger Method. Delivers end-to-end observable value instead of isolated technical tasks. CX Codex +1 172installs

Project sponsors

Companies that keep this analytics open