$ loading_
Write failing tests first to implement features and bug fixes reliably.
This skill appears to be a prompt-only test-driven development workflow with no declared secrets, remote endpoints, code execution, or data-access capabilities, so overall risk is low. Caution is warranted because the README contains strong agent-directed instructions (e.g., TodoWrite, creating a subagent), and the relationship between the listed source and the skill itself is not fully clear.
The material explicitly states that no secrets or environment variables are required, and it does not request API tokens, account credentials, or other sensitive authentication data, so credential exposure and abuse risk is low.
No remote endpoints or network dependencies are declared; the content is primarily a local development workflow description, with no stated behavior of sending user data to third-party services.
Based on the objective checks, this is a prompt-only skill and does not itself provide executable binaries or tool invocation capability. Although the README mentions running test commands and creating a subagent, those are textual instructions rather than evidence that the skill itself has system execution privileges.
No file, database, or other resource access scope is declared; the documentation only describes a test-first development method and does not show excessive data access or persistence behavior.
It is labeled open-source and sourced from GitHub, which meaningfully lowers risk; however, the mapping between the repository and the skill name/content is not fully clear, community adoption is 0 stars, the license is undeclared, maintenance status is unknown, and the README contains strong agent-instruction / workflow-injection style content. Manual verification of provenance and actual files is recommended before adoption.
Copy the install command and let the AI configure it · recommended for beginners
Please install the "test-driven-development" skill from askskill: 1. Download https://raw.githubusercontent.com/microsoft/FluidFramework/main/.agency/plugins/nori/skills/test-driven-development/SKILL.md 2. Save it as ~/.claude/skills/test-driven-development/SKILL.md 3. Reload skills and tell me it's ready
Use test-driven development to implement a user registration API: first list the test cases and write failing tests, then provide the minimal implementation code to make them pass, and finally briefly explain possible refactoring. Use Node.js + Express + Jest.
A set of initially failing then passing tests, the minimal implementation code, and brief refactoring suggestions.
I have a bug where checkout totals are calculated incorrectly. First write a failing test that reproduces the issue from the description, then provide the minimal fix, and add two edge-case tests to prevent regression. Use Python with pytest.
A complete TDD result including a bug reproduction test, a minimal fix, and additional regression tests.
Here is a piece of hard-to-test legacy code. Help me refactor it with a TDD approach: first identify observable behaviors and design failing tests, then gradually split the module and provide the smallest implementation changes, ensuring tests pass at each step. Organize the output step by step.
Step-by-step test design, an incremental refactoring plan, and implementation guidance for each step.
Write failing tests (RED phase)
Create a subagent using the nori-task-runner to evaluate test quality.
.claude/skills/creating-debug-tests-and-iteratingWrite one minimal test showing what should happen.
<good-example>test('retries failed operations 3 times', async () => {
let attempts = 0;
const operation = () => {
attempts++;
if (attempts < 3) throw new Error('fail');
return 'success';
};
const result = await foobar.retryOperation(operation);
expect(result).toBe('success');
expect(attempts).toBe(3);
});
Clear name, tests real behavior, one thing. Note that the tested operation is imported -- this is a STRONG sign that this is testing something real.
</good-example> <bad-example>test('retry works', async () => {
const mock = jest
.fn()
.mockRejectedValueOnce(new Error())
.mockRejectedValueOnce(new Error())
.mockResolvedValueOnce('success');
await retryOperation(mock);
expect(mock).toHaveBeenCalledTimes(3);
});
Vague name, tests mock not code </bad-example>
npm test path/to/test.test.ts
Confirm:
Write simplest code to pass the test.
<good-example> ```typescript async function retryOperation<T>(fn: () => Promise<T>): Promise<T> { for (let i = 0; i < 3; i++) { try { return await fn(); } catch (e) { if (i === 2) throw e; } } throw new Error('unreachable'); } ``` Just enough to pass </good-example> <bad-example> ```typescript async function retryOperation<T>( fn: () => Promise<T>, options?: { maxRetries?: number; backoff?: 'linear' | 'exponential'; onRetry?: (attempt: number) => void; } ): Promise<T> { // YAGNI } ``` Over-engineered </bad-example>Don't add features, refactor other code, or "improve" beyond the test.
npm test path/to/test.test.ts
Confirm:
After green only:
Keep tests green. Do not add behavior.
Create a custom skill with structure, documentation, and optional bundled scripts.
Trace errors backward through execution paths to identify the true root cause.
Update technical documentation after code changes are completed.
Generate Fluid-style PR content, push branches, and open GitHub pull requests.
Explains how to use abilities effectively before starting any conversation.
Break large, long-running tasks into manageable chunks and preserve context.
Implement features and fixes by writing tests before production code.
Use test-first development to improve code quality and maintainability.
Build features, fix bugs, and refactor code with test-driven development.
Write behavior-focused, refactor-resistant tests that verify intent and regressions.
Identify test anti-patterns and improve tests without polluting production code.
Systematically investigate bugs, test failures, and unexpected behavior before fixing.