writing-bodies-against-tests

Implement function bodies one at a time against frozen stubs and failing tests.

Updated May 7, 2026
One-click install
npx skills add https://github.com/TK-Evans01/tk-harness --skill writing-bodies-against-tests
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-bodies-against-tests
Source: https://github.com/TK-Evans01/tk-harness/tree/main/plugins/tk-rpie/skills/writing-bodies-against-tests
Command: npx skills add https://github.com/TK-Evans01/tk-harness --skill writing-bodies-against-tests

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

This Skill addresses the challenge of incrementally and precisely implementing function bodies in a codebase that already has frozen stubs and failing tests.

Core Features & Use Cases

  • Incremental Function Implementation: Write and test one function at a time to prevent batch debugging and improve code quality.
  • Frozen Contract Adherence: Ensures that stubs and tests remain immutable, maintaining a minimal feedback loop for each function.
  • Tier-2 FP Discipline: Enforces a functional programming approach to ensure code purity and robustness.

Quick Start

Invoke the writing-bodies-against-tests skill with the task assignment, and begin implementing the function bodies while adhering to the contract provided by the stubs and tests.

Frequently Asked Questions about writing-bodies-against-tests

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

FAQPage Schema
How do I implement function bodies against existing failing tests incrementally?▼

Implement function bodies against failing tests by writing and testing one function at a time. This incremental approach prevents batch debugging and maintains a minimal feedback loop while adhering to frozen stubs and input signatures.

What is the RPSTIE workflow for functional programming?▼

The RPSTIE workflow is a coding environment discipline for implementing function bodies with frozen stubs and failing tests. It enforces Tier-2 functional programming purity by requiring strict adherence to input signatures and per-function test execution.

How to ensure frozen contract adherence when writing code with failing tests?▼

Ensure frozen contract adherence by keeping stubs and tests immutable during function body implementation. This maintains a minimal feedback loop for each function and enforces strict compliance with the predefined input signatures.

Does this incremental test-driven implementation approach support functional programming discipline?▼

Yes, this incremental test-driven implementation enforces Tier-2 functional programming discipline. It ensures code purity and robustness by requiring strict adherence to input signatures and functional programming constraints during per-function test execution.

Why should I implement one function at a time instead of writing all function bodies at once?▼

Implementing one function at a time prevents batch debugging and improves code quality. By isolating each function body implementation with its own test execution, you maintain a minimal feedback loop and avoid cascading errors across the codebase.