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.