Results for “tdd”

Use when implementing a new function, adding a feature, fixing a bug, refactoring with test coverage, or writing a new test. Enforces strict outside-in red-green-refactor TDD with one-failure-per-turn discipline, predict-the-failure-before-every-run checks, hardcode-first minimum changes, triangulation, and property-based testing for large input spaces. Triggers on explicit TDD requests and on any task phrased as "implement", "add", "write a function", "build a feature", or "fix a bug" in a test-capable codebase. Reports red/green validation evidence.

The English summary is being prepared. Showing the original description.

エンジニアとして手を動かす作業全般で必ず発火させる: コードを書く / テストを書く / リファクタ / バグ修正 / E2E spec 追加 / 既存仕様への小さな修正など、コードに触る作業すべて。「実装して」「テスト書いて」「リファクタして」「バグ直して」のような依頼を受けたとき、または基本設計が済んで実装フェーズに入るときに発火。基本作業は TDD（テスト先書き → 最小実装 → リファクタ → コミット）で進め、要件が大きければ適切な小ささに分割しつつサイクルを回す。発火しないのは要件定義 / 基本設計の対話中（まだ手を動かしていない時）だけ。

The English summary is being prepared. Showing the original description.

Use when implementing features or fixing bugs with strict Test-Driven Development (TDD). Activate for coding tasks that require new functionality, refactoring, or comprehensive test coverage, especially when the user mentions TDD or Test Driven Development.

The English summary is being prepared. Showing the original description.

Guides agents through Red-Green-Refactor with runner-captured evidence. Use when running /cc-tdd-cycle, writing tests before implementation, or Global TDD required is yes.

The English summary is being prepared. Showing the original description.

Use when implementing features or fixing bugs with strict Test-Driven Development (TDD). Activate for coding tasks that require new functionality, refactoring, or comprehensive test coverage, especially when the user mentions TDD or Test Driven Development.

The English summary is being prepared. Showing the original description.

pytest-djangoによるDjangoテスト戦略、TDD方法論、factory_boy、モック、カバレッジ、Django REST Framework APIのテスト。

The English summary is being prepared. Showing the original description.

Run TDD cycle for feature implementation. Use when implementing features with RED-GREEN-REFACTOR, running test-driven development, automating TDD workflow, or ensuring test-first development.

The English summary is being prepared. Showing the original description.

Guides feature development and bug fixes by writing tests before implementation. It confirms each test fails for the expected reason, adds only enough code to pass, and checks the full test suite before completion.

• Implementing a new feature from tests
• Reproducing a bug in a test before fixing it
• Refactoring while keeping tests passing

Build features or fix bugs by writing one failing test, then the smallest implementation that passes it. Tests check behavior through public interfaces, the entry points callers use, so they remain useful when internal code changes.

• Building a feature one test at a time
• Fixing a bug with a failing test first
• Planning integration tests at agreed public interfaces

Turn a specification and its tickets into code by coordinating multiple agents around task dependencies. Combine their work on one integration branch, use test-driven development, review the result, and close tickets through the issue tracker’s workflow.

• Implementing a specification with multiple tickets
• Working on independent tickets in parallel
• Combining implementations on one integration branch

Implement work described in a specification or tickets, checking types and running tests along the way. Review the completed changes with the code-review skill, then commit the implementation to the current branch.

• Implementing a feature from a specification
• Implementing a referenced issue tracker ticket
• Checking changes with types and tests

Audit a focused part of an existing codebase, reconstruct its behavior and past decisions, and record gaps in reasoning, coding practices, features, and technology choices. Use the findings to plan, test, implement, and verify improvements.

• Review an inherited codebase
• Adopt the ECC engineering workflow midway through a project
• Rethink a module before adding more features

Write and run Perl tests with Test2::V0 or Test::More, replace external dependencies with controlled test substitutes, and measure coverage—the code exercised by tests. Guidance covers test-first development, failure diagnosis, and migration between testing modules.

• Writing Perl tests before implementation
• Migrating tests from Test::More to Test2::V0
• Testing API and database interactions in isolation

Write Rust unit, integration, and async tests using a test-first workflow. Covers generated test inputs, mock dependencies, performance benchmarks, and coverage checks to assess behavior and identify code that remains untested.

• Developing Rust functions with tests first
• Adding tests to existing code
• Testing async operations and timeouts

Build and review Python tests with pytest. Use reusable setup, simulated external services, and multiple input cases to check behavior, then measure coverage—the proportion of code exercised by tests—and follow a test-first development cycle.

• Writing tests before implementing a Python feature
• Sharing test setup through reusable fixtures
• Testing external API behavior with mocks

Build features or fix bugs by writing a small test first, checking that it fails for the expected reason, and making the smallest code change needed. Run related tests and review the changes for unintended effects.

• Reproducing a bug with a regression test
• Defining expected behavior before implementing a feature
• Checking parser, routing, or UI behavior changes

Improve existing code through repeated cycles of testing, implementation, and refactoring. The skill covers performance bottlenecks, error recovery, code coverage, and documentation, helping developers refine behavior and structure while keeping tests passing.

• Refactoring existing code while keeping tests passing
• Adding tests before implementing expected behavior
• Investigating slow database access and cache usage

Turn specifications and designs into working code using test-driven development: write failing tests, implement enough code to pass, then refactor. The workflow also covers error handling, performance improvements, documentation, and coordinated changes across components.

• Implementing a feature from specifications and designs
• Developing authentication or APIs with tests
• Refactoring code while checking test results

Organize software development from requirements and design through testing, review, and deployment. Uses Claude Flow to coordinate specialized agents, share decisions across sessions, and guide implementation with tests written before code.

• Developing a feature from requirements through review
• Refactoring legacy code with supporting tests
• Investigating bugs and adding regression tests

Write JavaScript and TypeScript tests with Jest, Vitest, and Testing Library. Covers functions, UI components, and APIs, including mock replacements for external services, reusable test data, and setup for automated testing.

• Set up testing for a new project
• Test functions and API error handling
• Check React component behavior

Develop behavior through one failing test and one minimal implementation at a time. Tests use agreed interfaces and expected results from specifications or documented examples, producing evidence of both failure and success, including for bug fixes.

• Adding behavior through small test-first steps
• Reproducing a bug before fixing it
• Checking results against specifications

Guide changes to the published @kortix/sdk package with rules for preserving public APIs, writing failing tests before behavior changes, keeping the core independent of frameworks, and checking package installation. It also covers exports, streaming transport, and release version handling.

• Adding a public SDK feature or export
• Renaming public types while preserving compatibility
• Changing streaming or transport behavior

Add new operators to MNN through a staged workflow covering data definitions, output shapes, computation, and tests. It prioritizes combining existing operators, with CPU implementations and additional hardware backends used when needed.

• Adding a new operator to MNN
• Implementing output shape calculations
• Combining existing operators for new operations

Guide development from problem definition and planning through testing, debugging, review, and final verification. It uses test-driven development, writing a failing test before implementation, and requires evidence before reporting work as complete.

• Define a development goal and acceptance checks
• Implement a change starting with a failing test
• Investigate a reproducible bug through small experiments