tk

Enforce contracts and invariants to turn change requests into verifiable patches.

66|2|Updated Feb 18, 2015
One-click install
npx skills add https://github.com/tkersey/dotfiles --skill tk
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tk
Source: https://github.com/tkersey/dotfiles/tree/main/codex/skills/tk
Command: npx skills add https://github.com/tkersey/dotfiles --skill tk

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

## What problem does it solve? TK solves the problem of turning vague change requests into minimal, verifiable patches by enforcing a stable boundary with a clearly defined contract and invariants.

## Core Features & Use Cases

  • Contract and invariant articulation at the boundary to prevent drift.
  • Creative framing to explore alternatives without increasing risk.
  • Minimal incision discipline for reviewable patches with an executable proof signal.
  • Use Case: when refactoring or evolving behavior in a complex system while preserving contracts.

### Quick Start To start, define a Contract, articulate Invariants, choose a Creative Frame, and perform an Incision that can be validated by a local test.

Frequently Asked Questions about tk

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

FAQPage Schema
How do I turn vague change requests into minimal, verifiable code patches?

To turn vague change requests into minimal, verifiable code patches, you define a stable boundary with a clear contract and invariants, then perform a minimal incision validated by a local test or type check.

What is the best way to refactor complex system behavior while preserving existing contracts?

The best way to refactor complex system behavior while preserving contracts is to apply minimal incision discipline, ensuring changes are reviewable and accompanied by an executable proof signal like a test or type check.

How do I ensure my code refactoring produces traceable and reproducible proof signals?

To ensure code refactoring produces traceable and reproducible proof signals, you articulate invariants, define a contract, and validate your minimal incision patch using local tests or type checks as the proof signal.

When do I need contract and invariant articulation for software surgery?

You need contract and invariant articulation for software surgery when refactoring or evolving behavior in a complex system, ensuring strict discipline to prevent drift and maintain traceable, verifiable changes.

Does minimal incision discipline work without a predefined creative frame?

Minimal incision discipline works best with a predefined creative frame because the frame allows you to explore alternatives without increasing risk, keeping the resulting patch reviewable and verifiable.

What limitations exist when using minimal incision for vague code change requests?

A key limitation of minimal incision for vague code change requests is that it requires strict contract and invariant discipline to succeed, meaning without a clearly defined boundary, the verifiable patch may fail to prevent drift.