TERMINUS PROTOCOL

The Three Phases

Phase 1

Design

Derive the kernel. Define goal, scope, and invariants. Expand into a full spine. Define loops and branches. Choose implementation only after the spine is known.

Phase 2

Implementation

Execution begins at Loop 1, Branch 1 and proceeds through the defined spine. Implementation does not redesign the system. Contradictions return to Phase 1.

Phase 3

Testing & Release

Testing, fixing, refinement, packaging, and release preparation. Only after the spine is fully executed. Polish is not a substitute for incomplete implementation.

Kernel → Spine → Loops → Branches Phase 1: Design — derive kernel, define spine, choose implementation path Phase 2: Implementation — Loop 1 Branch 1 → … → Last Loop, Last Branch Phase 3: Release — testing, fixing, refinement, packaging

The KFL Lexicon

KERNEL

The Irreducible Core

The problem being solved, the intended outcome, and the essential mechanism. Everything expands from the kernel. If the kernel is unclear, the project is not ready to build.

SPINE

The Complete Structural Path

The full path to a v1 artifact. Designed completely during Phase 1. It defines loops, branches, and the completion boundary. The build path is known before execution begins.

LOOP

Bounded Unit of Action

A loop has a start, middle, and end. Containment structures, not repetitions. A loop only matters if it can be entered, traversed, and exited.

BRANCH

Concrete Work Paths

Actionable subunits inside a loop — building a parser, defining a schema, implementing a view, wiring a persistence layer. Progress through branches one by one.

FRACTAL

Self-Similar at Every Scale

The same bounded structure repeats across project lifecycle, design process, implementation loops, and branch-level execution. Structure begins when an idea is formalized, not when code is written.

Tools

PromptTrim

Code prompt cost auditor · find the waste, keep the signal

100% local. Runs entirely in your browser. No uploads, no tracking, no server calls.

⚙ Assumptions & Pricing

Chars per tokenDefault 4. Lower = higher estimate.

Opus $/M (in/out)

Sonnet $/M (in/out)

Haiku $/M (in/out)

System Prompt (optional)0 chars · ~0 tokens

Your Prompt0 chars · ~0 tokens

Drop your Claude export .json here

Settings → Account → Export Data on claude.ai

Analyzing

Kernel Fractal Loop (KFL)

AI can accelerate building, but it can also accelerate drift. A promising idea becomes five half-built variants, the architecture keeps moving, and nothing stable gets released. KFL is the operating method developed to counter that failure mode.

Why this method exists

KFL did not arrive as a theory exercise. It emerged from trying to actually ship work with AI systems without getting pulled into endless redesign, agent sprawl, or unfinished prototypes. The method exists because ideas need containment — through a small set of structural rules: define the kernel, design the spine fully, execute through bounded loops, and do not blur implementation with redesign.

This became especially important once AI-assisted development made it possible to generate far more work than most people can evaluate or stabilize in real time. Without structure, execution can outrun coherence.

The core principle

Kernel defines the work.
The spine structures the work.
Loops bound the work.
Branches execute the work.

Roles inside the method

Responsible Party / Liaison

The human builder remains the Responsible Party — owns outcomes, authorizes phase transitions, serves as liaison to implementation. Responsibility is not delegated away.

Lead of Implementation

The AI system can act as Lead of Implementation — executing the approved spine, translating directives into actionable work, preserving invariants, flagging misunderstandings, preventing drift.

Why KFL works well with AI

AI systems are very good at generation, exploration, and rapid iteration. They are much less reliable when left to define structure implicitly while also trying to execute it. KFL introduces containment: explicit design boundaries, defined phase transitions, bounded loops, concrete branches, and a strict return path when implementation uncovers design flaws.

What KFL is meant to improve

Finishing work instead of circling it
Keeping implementation aligned with design
Using AI as a force multiplier instead of a source of drift
Making the path from idea to release inspectable

Where this came from

KFL came out of repeated real-world AI co-creation work: designing tools, refining scope, coordinating builds, correcting drift, and trying to get from concept to something stable enough to release. An operational method shaped by practice.

Final principle