Agent skill

TDD

by codewithmukesh in codewithmukesh/dotnet-claude-kit

Guided test-driven development workflow for .NET 10 using xUnit v3, WebApplicationFactory, Testcontainers, and Verify snapshots.

MITAuto-check passedTesting & QA

Install TDD

skills CLI

$ npx skills add codewithmukesh/dotnet-claude-kit --skill tdd -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI

$ gh skill install codewithmukesh/dotnet-claude-kit tdd --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy

$ git clone --depth 1 https://github.com/codewithmukesh/dotnet-claude-kit.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/tdd .claude/skills/tdd && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Paste into Claude Code

Install the "tdd" agent skill from https://github.com/codewithmukesh/dotnet-claude-kit/tree/main/skills/tdd into .claude/skills/tdd/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "tdd", then confirm the skill loads.

Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

$skill-installer

$skill-installer install https://github.com/codewithmukesh/dotnet-claude-kit/tree/main/skills/tdd

Type this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.

skills CLI

$ npx skills add codewithmukesh/dotnet-claude-kit --skill tdd -a codex

Project install goes to .agents/skills/; add -g for ~/.codex/skills/.

GitHub CLI

$ gh skill install codewithmukesh/dotnet-claude-kit tdd --agent codex

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/codewithmukesh/dotnet-claude-kit.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/tdd .agents/skills/tdd && rm -rf skills-src

Use ~/.agents/skills/ instead of .agents/skills for a personal install.

Codex skills documentation · loads skills from .agents/skills/

Paste into Codex

Install the "tdd" agent skill from https://github.com/codewithmukesh/dotnet-claude-kit/tree/main/skills/tdd into .agents/skills/tdd/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "tdd", then confirm the skill loads.

Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add codewithmukesh/dotnet-claude-kit --skill tdd -a cursor

Project install goes to .agents/skills/; add -g for ~/.cursor/skills/.

GitHub CLI

$ gh skill install codewithmukesh/dotnet-claude-kit tdd --agent cursor

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/codewithmukesh/dotnet-claude-kit.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/tdd .cursor/skills/tdd && rm -rf skills-src

Use ~/.cursor/skills/ instead of .cursor/skills for a personal install.

Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/

Paste into Cursor

Install the "tdd" agent skill from https://github.com/codewithmukesh/dotnet-claude-kit/tree/main/skills/tdd into .cursor/skills/tdd/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "tdd", then confirm the skill loads.

Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

gemini skills install

$ gemini skills install https://github.com/codewithmukesh/dotnet-claude-kit.git --path skills/tdd

--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.

skills CLI

$ npx skills add codewithmukesh/dotnet-claude-kit --skill tdd -a gemini-cli

Project install goes to .agents/skills/; add -g for ~/.gemini/skills/.

GitHub CLI

$ gh skill install codewithmukesh/dotnet-claude-kit tdd --agent gemini-cli

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/codewithmukesh/dotnet-claude-kit.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/tdd .gemini/skills/tdd && rm -rf skills-src

Use ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.

Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/

Paste into Gemini CLI

Install the "tdd" agent skill from https://github.com/codewithmukesh/dotnet-claude-kit/tree/main/skills/tdd into .gemini/skills/tdd/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "tdd", then confirm the skill loads.

Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

GitHub CLI

$ gh skill install codewithmukesh/dotnet-claude-kit tdd

Installs for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).

skills CLI

$ npx skills add codewithmukesh/dotnet-claude-kit --skill tdd -a github-copilot

Project install goes to .agents/skills/; add -g for ~/.copilot/skills/.

Manual copy

$ git clone --depth 1 https://github.com/codewithmukesh/dotnet-claude-kit.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/tdd .github/skills/tdd && rm -rf skills-src

Use ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.

GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/

Paste into GitHub Copilot

Install the "tdd" agent skill from https://github.com/codewithmukesh/dotnet-claude-kit/tree/main/skills/tdd into .github/skills/tdd/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "tdd", then confirm the skill loads.

GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add codewithmukesh/dotnet-claude-kit --skill tdd -a opencode

OpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.

GitHub CLI

$ gh skill install codewithmukesh/dotnet-claude-kit tdd --agent opencode

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/codewithmukesh/dotnet-claude-kit.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/tdd .opencode/skills/tdd && rm -rf skills-src

Use ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.

OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/

Paste into OpenCode

Install the "tdd" agent skill from https://github.com/codewithmukesh/dotnet-claude-kit/tree/main/skills/tdd into .opencode/skills/tdd/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "tdd", then confirm the skill loads.

OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

Facts

Skill name: tdd
GitHub stars: 751
Token cost: ~1.4k tokens
SKILL.md length: 470 words
Files: 1
Skills in repo: 47
Repo updated: Aug 7, 2026
First seen: Oct 7, 2026
Licence: MIT

At a glance

Guided test-driven development workflow for .NET 10 using xUnit v3, WebApplicationFactory, Testcontainers, and Verify snapshots.

Works in 3 steps: Red -- Write the Failing Test → Green -- Minimal Implementation → Refactor -- Clean Up with Confidence
Red green refactor
SKILL.md covers What, When, How and Example, plus 1 more section
Calls dotnet

What it does

TDD is an agent skill from codewithmukesh/dotnet-claude-kit. Guided test-driven development workflow for .NET 10 using xUnit v3, WebApplicationFactory, Testcontainers, and Verify snapshots. Follows the strict red-green-refactor cycle. Use when: "TDD", "test-driven", "let's TDD this", "red green refactor", "write the test first", or when building a feature with clear acceptance criteria.

Its SKILL.md is about 1.4k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Testing & QA, covering Test-driven development. It works with .NET. The repository describes itself as: Make Claude Code a .NET 10 Expert. The licence is MIT.

When your agent uses it

Red green refactor
Write the test first
Building a feature with clear acceptance criteria

Example prompts

“test-driven”
“s TDD this”
“red green refactor”
“/tdd”

Workflow steps

3 steps, taken from the step headings in SKILL.md.

Red -- Write the Failing Test
Green -- Minimal Implementation
Refactor -- Clean Up with Confidence

What it can do on your machine

Read from SKILL.md and the folder at commit 2330089. It shows what the files ask for, not the result of running them.

Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
Shell commands in SKILL.md call:
- dotnet
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

TDD loads about 1.4k tokens when it runs. Until then it costs about 83 tokens; SKILL.md has 470 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it: ~83
When it runs · the whole SKILL.md, loaded when a task matches: ~1.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from codewithmukesh/dotnet-claude-kit at commit 2330089, republished under its MIT licence (© codewithmukesh). 470 words, ~1,381 tokens.

Download SKILL.mdSave it as .claude/skills/tdd/SKILL.md (or your agent's skills folder).

name: tdd
description: Guided test-driven development workflow for .NET 10 using xUnit v3, WebApplicationFactory, Testcontainers, and Verify snapshots. Follows the strict red-green-refactor cycle. Use when: "TDD", "test-driven", "let's TDD this", "red green refactor", "write the test first", or when building a feature with clear acceptance criteria.

/tdd -- Red-Green-Refactor for .NET

What

Guides a strict test-driven development cycle for .NET features. Instead of writing implementation first and bolting on tests after, this command flips the order: write a failing test that defines the desired behavior, implement the minimum code to make it pass, then refactor with confidence.

Every cycle uses the .NET testing stack:

xUnit v3 -- Test framework with [Fact] and [Theory]
WebApplicationFactory -- Integration tests against the real HTTP pipeline
Testcontainers -- Real databases (PostgreSQL, SQL Server) in tests
Verify -- Snapshot testing for complex response structures
FakeTimeProvider -- Deterministic time in tests

When

User says "TDD", "test-driven", "let's TDD this", "write the test first"
Building a new feature with clear acceptance criteria
Fixing a bug (write a test that reproduces the bug first, then fix)
Adding behavior to an existing feature (test the new behavior first)
Any time the user wants proof that code works before it ships

Skip TDD for: Trivial config changes, scaffolding without logic, documentation.

How

Cycle: Red -> Green -> Refactor

Each feature goes through one or more TDD cycles. A cycle covers one discrete behavior.

Step 1: Red -- Write the Failing Test

Write a test that describes the desired behavior. The test MUST fail because the implementation does not exist yet.

csharp

[Fact]
public async Task CreateOrder_WithValidItems_Returns201WithOrderId()
{
    // Arrange
    var client = _factory.CreateClient();
    var request = new CreateOrderRequest([
        new OrderItemRequest("SKU-001", 2, 29.99m)
    ]);

    // Act
    var response = await client.PostAsJsonAsync("/api/orders", request);

    // Assert — plain xUnit Assert (FluentAssertions v8+ requires a commercial license)
    Assert.Equal(HttpStatusCode.Created, response.StatusCode);
    var result = await response.Content.ReadFromJsonAsync<CreateOrderResponse>();
    Assert.NotNull(result);
    Assert.NotEqual(Guid.Empty, result.OrderId);
}

Run the test and confirm it fails:

bash

dotnet test --filter "CreateOrder_WithValidItems_Returns201WithOrderId"

If the test passes without implementation, the test is not testing what you think. Rewrite it.

Step 2: Green -- Minimal Implementation

Write the minimum code to make the test pass. Do not add features, optimizations, or edge case handling. The goal is a green test, nothing more.

Create the endpoint, handler, request/response types, and EF config as needed
Use the simplest logic that satisfies the test assertion
Do not refactor yet -- ugly passing code is fine at this stage

Run the test and confirm it passes:

bash

dotnet test --filter "CreateOrder_WithValidItems_Returns201WithOrderId"

Show full SKILL.md (172 more words)Show less

Step 3: Refactor -- Clean Up with Confidence

Now that the test is green, refactor freely:

Extract methods, rename variables, improve structure
Apply modern C# patterns (primary constructors, records, collection expressions)
Add validation, error handling, and edge cases (with new tests for each)
Run the full test suite after each refactor step to catch regressions

bash

dotnet test

If any test goes red during refactoring, undo the last change and try a smaller step.

Multi-Cycle Features

Most features require multiple TDD cycles. Plan the cycles upfront:

Feature: Order Management

Cycle 1: Create order with valid items -> 201
Cycle 2: Create order with empty items -> 400 validation error
Cycle 3: Create order with invalid SKU -> 400 with specific error
Cycle 4: Get order by ID -> 200 with full order details
Cycle 5: Get order that does not exist -> 404

Each cycle adds one behavior. Never combine multiple behaviors in a single cycle.

Test Infrastructure Setup

If the project lacks test infrastructure, set it up before the first cycle:

Create test project with xUnit v3 and required packages
Configure WebApplicationFactory with Testcontainers for the real database
Add a shared fixture to avoid spinning up containers per test class
Verify the infrastructure with a simple health-check test

Example

User: /tdd Let's TDD a product search endpoint

Claude: I'll plan the TDD cycles for product search:

Cycle 1: Search with matching term returns matching products
Cycle 2: Search with no matches returns empty list
Cycle 3: Search with pagination returns correct page
Cycle 4: Search with filters narrows results

Starting Cycle 1: Red phase
Writing a failing integration test for basic product search...

[writes test, runs it, confirms failure]

Cycle 1: Green phase
Implementing the minimum to make the search test pass...

[implements, runs test, confirms pass]

Cycle 1: Refactor phase
The implementation works but the query could use a projection
instead of loading full entities. Refactoring...

[refactors, runs full suite, all green]

Cycle 1 complete. Moving to Cycle 2...

/verify -- Run full verification after completing all TDD cycles
/scaffold -- Generate initial feature structure that tests will drive

Files

Just SKILL.md in skills/tdd of codewithmukesh/dotnet-claude-kit.

Open the folder on GitHubat commit 2330089

Compare with similar skills

TDD next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

TDD compared with similar skills
Skill	Stars	Used in	Tokens	Auto-check	Licence	Repo updated
TDD this skillcodewithmukesh/dotnet-claude-kit	751	—	~1.4k	Automated safety check: Pass	MIT	2 mo ago
Test Firstdeanhume/html-minifier	142	—	~876	Automated safety check: Pass	MIT	today
New EndpointVonage/vonage-dotnet-sdk	118	—	~11k	Automated safety check: Pass	Apache-2.0	4 mo ago
Et TDDFlameskyDexive/Legends-Of-Heroes	929	—	~243	Automated safety check: Pass	MIT	16 days ago
Development Workflowrunceel/ReactiveProperty	944	—	~1.4k	Automated safety check: Pass	MIT	1 mo ago
Jest Testing PatternsChrisWiles/claude-code-showcase	6.1k	7 repos	~1.5k	Automated safety check: Pass	None	9 mo ago

Similar skills

Test First
deanhume/html-minifier
Enforces a strict test-driven development (TDD) workflow for the HTML Minifier repo.
142 GitHub stars~876 tokensUpdated today
Testing & QAAuto-check passed
New Endpoint
Vonage/vonage-dotnet-sdk
Add a new endpoint, use case, or product to the Vonage .NET SDK.
118 GitHub stars~11k tokensUpdated 4 mo ago
Testing & QAAuto-check passed
Et TDD
FlameskyDexive/Legends-Of-Heroes
ET test-driven development workflow for WOW. An agent skill from FlameskyDexive/Legends-Of-Heroes.
929 GitHub stars~243 tokensUpdated 16 days ago
Testing & QAAuto-check passed
Development Workflow
runceel/ReactiveProperty
ReactiveProperty repository development policy. An agent skill from runceel/ReactiveProperty.
944 GitHub stars~1.4k tokensUpdated 1 mo ago
DevelopmentAuto-check passed
Jest Testing Patterns
ChrisWiles/claude-code-showcase
Jest patterns for React Native style tests: TDD discipline, mock factory functions, module and GraphQL hook mocking, custom render helpers and anti-patterns to avoid.
6.1k GitHub starsUsed in 7 repos~1.5k tokens
Testing & QAAuto-check passed
Rust TDD Workflow
rtk-ai/rtk
Enforces red-green-refactor for Rust work, with idiomatic test patterns, a naming convention and a pre-commit gate of cargo fmt, clippy and test.
83k GitHub stars~753 tokensUpdated today
Testing & QAAuto-check: notes

Questions about TDD

What does TDD do?

Guided test-driven development workflow for .NET 10 using xUnit v3, WebApplicationFactory, Testcontainers, and Verify snapshots. TDD is an agent skill from codewithmukesh/dotnet-claude-kit.NET 10 using xUnit v3, WebApplicationFactory, Testcontainers, and Verify snapshots.

When should I use TDD?

TDD fits situations like: red green refactor; write the test first; building a feature with clear acceptance criteria.

How do I install TDD in Claude Code?

Run `npx skills add codewithmukesh/dotnet-claude-kit --skill tdd -a claude-code`. Or copy the skill folder (skills/tdd in codewithmukesh/dotnet-claude-kit) into .claude/skills/tdd in your project. Claude Code loads it when a task matches its description.

How do I install TDD in Codex?

Run `npx skills add codewithmukesh/dotnet-claude-kit --skill tdd -a codex`. Or copy the skill folder (skills/tdd in codewithmukesh/dotnet-claude-kit) into .agents/skills/tdd in your project. Codex loads it when a task matches its description.

Can I use TDD in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add codewithmukesh/dotnet-claude-kit --skill tdd -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/tdd, .gemini/skills/tdd, .github/skills/tdd and .opencode/skills/tdd in your project.

What does TDD need to run?

Going by SKILL.md and its folder, TDD needs the command-line tools its instructions call (dotnet).

Does TDD access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is TDD safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does TDD use?

TDD is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does TDD use?

About 1.4k tokens (SKILL.md is roughly 5.5k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to TDD?

Skills that share tags, products or a category with TDD: Test First (deanhume/html-minifier, 142 stars), New Endpoint (Vonage/vonage-dotnet-sdk, 118 stars), Et TDD (FlameskyDexive/Legends-Of-Heroes, 929 stars) and Development Workflow (runceel/ReactiveProperty, 944 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains TDD?

codewithmukesh (a GitHub organization) maintains it in codewithmukesh/dotnet-claude-kit, which has 751 GitHub stars. The repository holds 47 skills in this directory. The repository was last updated on August 7, 2026.

Source: codewithmukesh/dotnet-claude-kit on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.

Install TDD

Facts

At a glance

What it does

When your agent uses it

Example prompts

Workflow steps

What it can do on your machine

Tool permissions

Runs code

Network

Credentials

Context cost

Safety

SKILL.md

/tdd -- Red-Green-Refactor for .NET

What

When

How

Cycle: Red -> Green -> Refactor

Step 1: Red -- Write the Failing Test

Step 2: Green -- Minimal Implementation

Step 3: Refactor -- Clean Up with Confidence

Multi-Cycle Features

Test Infrastructure Setup

Example

Related

Files

Compare with similar skills

Similar skills

More from codewithmukesh/dotnet-claude-kit

Related

Questions about TDD