tpp-rules

Apply the Transformation Priority Premise to select the simplest code transformation for failing tests.

1|Updated Jan 13, 2023

Search Tags:#testing #tdd #refactoring #software development #transformation #priority

Ready to run

npx skills add https://github.com/theodrosyimer/.dotfiles --skill tpp-rules

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: tpp-rules
Source: https://github.com/theodrosyimer/.dotfiles/tree/main/claude/skills/dev__tpp-rules
Command: npx skills add https://github.com/theodrosyimer/.dotfiles --skill tpp-rules

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Developers often over‑engineer code during Test‑Driven Development, jumping to complex implementations that bypass incremental learning. This Skill provides the Transformation Priority Premise to enforce the simplest viable change for each failing test.

Core Features & Use Cases

Priority List: A twelve‑step ordered list of transformations from “no code” to “variable assignment”.
Core Rules: Guidelines to pick the simplest transformation, avoid level skipping, and align test ordering with implementation.
Calibration Catalog: Example approvals and blocks to keep reviewers consistent.
Reference Document: Detailed description of each transformation and its application.
Use Case: Apply TPP when building a booking system, ensuring each new test introduces only one transformation step.

Quick Start

Ask the TPP skill to evaluate the next failing test and suggest the simplest transformation.

Frequently Asked Questions about tpp-rules

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

FAQPage Schema

What is the Transformation Priority Premise in TDD and how does it prevent over-engineering?▼

The Transformation Priority Premise is a TDD technique that enforces the simplest viable code change to pass a failing test. It provides a twelve-level ordered list to prevent developers from skipping steps and jumping to complex implementations during incremental test suite development.

How do I apply the simplest code transformation when my TDD test fails?▼

To apply the simplest TDD code transformation, evaluate the failing test and select the next transformation from the twelve-level priority list. Enforce a one-step-down progression to ensure the implementation aligns incrementally with test ordering without level skipping.

Can I use the Transformation Priority Premise for incremental test suites in software development?▼

Yes, the Transformation Priority Premise is designed for incremental test suites in software development. It applies specifically during the RED and GREEN phases of Test-Driven Development to guide developers through gradual, one-step-down code transformations.

What's the best way to pick the right code transformation when refactoring during TDD?▼

The best way to pick the right TDD transformation is to consult the provided calibration catalog. This catalog contains example approvals and blocks designed to keep code reviews consistent and calibrate judgments when selecting from the twelve-step transformation list.

Why does my TDD implementation become too complex when adding new tests?▼

Your TDD implementation becomes complex when you skip transformation levels and bypass incremental learning. Using the Transformation Priority Premise enforces a one-step-down progression through its twelve-level list, ensuring each new test introduces only one simple transformation step.