skills.rest
po4yka
po4ykaCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

tdd

Enforce RED/GREEN/REFACTOR test-first workflows for Kotlin/JVM and Rust codebases.

58|4|Updated Mar 8, 2026
Search Tags:#testing#tdd#rust#test-driven#kotlin#ci#golden-contracts
One-click install
npx skills add https://github.com/po4yka/RIPDPI --skill tdd-po4yka
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: tdd
Source: https://github.com/po4yka/RIPDPI/tree/main/.github/skills/tdd
Command: npx skills add https://github.com/po4yka/RIPDPI --skill tdd-po4yka

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Test-first development ensures behavior is specified via tests before implementation, reducing regressions and improving maintainability.

Core Features & Use Cases

  • Enforces RED/GREEN/REFACTOR workflow to structure feature work and bug fixes.
  • Cross-language guidance for Kotlin/JVM and Rust projects, with module-specific test commands.
  • Comprehensive testing conventions including Fake test doubles, golden contracts, and CI/testing best practices.

Quick Start

Write a failing test first, then implement the minimal code to pass, and finally refactor for quality.

Frequently Asked Questions about tdd

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I enforce a test-first workflow for Rust and Kotlin codebases?▼

Enforce a test-first workflow by guiding developers through RED/GREEN/REFACTOR cycles, requiring explicit tests and module-specific test commands before implementing features or bug fixes in Kotlin/JVM and Rust codebases.

What is the RED/GREEN/REFACTOR cycle for test-driven development?▼

The RED/GREEN/REFACTOR cycle structures test-driven development by first writing a failing test, then implementing minimal code to pass, and finally refactoring for quality to reduce regressions and improve maintainability.

Can I use fake test doubles and golden contracts for CI testing in Kotlin and Rust?▼

Yes, you can use Fake test doubles and golden contracts for CI testing in Kotlin and Rust projects. Comprehensive testing conventions include these practices alongside documented running commands across modules.

Does test-driven development work for both feature work and bug fixes?▼

Test-driven development works for both feature work and bug fixes in Kotlin/JVM and Rust projects. It structures the workflow by requiring explicit tests before implementation across all module-specific development tasks.

What are the limitations of test-driven development for cross-language projects?▼

Test-driven development for cross-language projects requires explicit tests, fake test doubles, and documented running commands across modules. Limitations include the overhead of maintaining golden contracts and module-specific test commands for Kotlin and Rust.

Why does test-first development reduce regressions in software engineering?▼

Test-first development reduces regressions because behavior is specified via tests before implementation. This test-driven approach enforces explicit testing conventions and golden contracts, improving overall software maintainability.

Related Skills

Explore More Software Engineering Skills→
hyxkleehyxklee

red-green-refactor

Guide Kotlin/JVM developers through TDD Red-Green-Refactor cycles with Kotest DescribeSpec.

Community
Intermediate
po4ykapo4yka
58

kotlin-test-patterns

Standardize Kotlin test patterns for unit, Compose, Hilt, and coroutine tests.

Community
Advanced
andymaiandymai
20

testing

Automate test execution and regression detection in the brepkit environment.

Community
Advanced
narumirunanarumiruna
8

test-driven-development

Enforce red/green/refactor cycles for feature development, bug fixes, and refactors.

Community
Intermediate