◆ Kernel-Spine-Loop ◆

TERMINUS PROTOCOL

A disciplined method for building with AI without losing the shape of the work.

Truth before completion. Sovereignty before convenience.

Map → Walk → Verify

KSL turns intent into a bounded work map, walks that map through Think → Do → Exit loops, and checks the produced artifact against the original Kernel.

The Three Stages

Stage 1

Map the Spine

Kernelize the goal. Define what must be true, what counts as done, what is out of scope, and what path the work must walk. Stage 1 is the only place where the Goal and Map may be iterated.

Stage 2

Walk the Spine

Walk the approved Spine one Vertebra at a time. Each bounded loop moves through Think → Do → Exit. Local thinking is allowed. Silent global remapping is not.

Stage 3

Verify the Artifact

Check the produced artifact against the Kernel. If it aligns, the work is done. If it fails, return to Stage 1 and map the hardening Spine.

KSL Method Diagram

Kernelize → Walk → Verify
KSL is fractal traversal: Stage 1 maps the Spine, Stage 2 walks it through Think → Do → Exit loops, and Stage 3 verifies the artifact against the Kernel.
Kernel Spine Vertebrae Think Do Exit
Structural Spine
01 / Truth

Kernel

The irreducible target truth: what is being made, why it matters, what must remain true, what is excluded, and what counts as done.

02 / Map

Spine

The approved work map from Entry to Exit. Stage 2 walks this map; it does not quietly rewrite it while moving.

03 / Segment

Vertebra

One load-bearing chunk of the Spine. A Vertebra is small enough to execute and large enough to matter.

04 / Loop

Think → Do → Exit

The loop engine. Think defines the local move. Do performs it. Exit proves the loop may close with an artifact, receipt, gate, or handoff.

05 / Amendment

Stop Before Scope Widens

If Stage 2 reveals the Goal, Scope, or Map must change, the walk stops. Completed upstream work is preserved. Downstream work is amended through Stage 1.

06 / Proof

Receipt

Proof of traversal: what changed, what exists, what was verified, what remains unverified, and where the next safe boundary begins.

Stage 1 owns the map

Kernelize + Map

Iterate the Goal and Map until the work has a bounded Spine. Name the Vertebrae, context needs, exits, and receipts before build energy takes over.

  • Kernel
  • Goal
  • Bounds
  • Spine
  • Vertebrae
  • Exit gates
Output approved traversal map
Stage 2 owns traversal

Walk the Spine

Execute the mapped work one Vertebra at a time. Stage 2 may think locally inside the current loop; it may not silently mutate the whole map.

  • Think
  • Do
  • Exit
  • Receipts
  • Preserve upstream
Output artifact with traversal receipts
Stage 3 owns alignment

Verify Against Kernel

Compare the artifact to the Kernel. If it aligns, it is done. If it fails, the deficiency becomes a new Stage 1 hardening map.

  • Alignment check
  • Deficiency report
  • Hardening map
  • Release decision
Output done or remapped

KSL Lexicon

KERNEL

The Irreducible Target

The truth the artifact must satisfy. The Kernel anchors the goal, the boundary, and the definition of done.

SPINE

The Work Map

The ordered traversal from Entry to Exit. Stage 1 maps it. Stage 2 walks it.

VERTEBRA

A Load-Bearing Chunk

A bounded segment or step on the Spine. Each Vertebra has a purpose, entry condition, exit condition, and receipt requirement.

LOOP

Think → Do → Exit

Think locally. Do the bounded work. Exit with proof. A loop may repeat only inside its boundary.

AMENDMENT

No Silent Map Mutation

If the map breaks, stop. Preserve upstream work. Amend downstream through Stage 1 instead of pretending the map was always different.

RECEIPT

Proof of Traversal

A receipt records what changed, what was produced, what was checked, what remains unknown, and what boundary is safe to cross next.

KSL for real

KSL is not a productivity slogan. It is a traversal discipline for AI-assisted work: map the goal, walk the map, and verify the artifact against the Kernel.

Stage 1

Only Stage 1 iterates the Goal and Map

Stage 1 is iterative contemplation with a job: produce the bounded Spine that Stage 2 can walk.

Stage 2

Stage 2 thinks locally, not globally

Build work can reason inside the current Vertebra, but it cannot silently widen scope or rewrite the Spine.

Stage 3

Stage 3 judges alignment

The artifact is checked against the Kernel. Pass means done. Failure means a new hardening map.

Why the distinction matters

AI can make work faster, but speed makes drift cheaper. Without a map, implementation can quietly become a different project. KSL prevents that by separating mapmaking from traversal.

Stage 1 maps. Stage 2 walks. Stage 3 verifies.

The Loop

Every bounded pass through the work uses the same loop:

ThinkDoExit

Exit is not a vibe. It is the proof that the loop may close: an artifact, a receipt, a test result, a handoff, or a clear deficiency marker.

The Amendment Law

Upstream is set. Downstream may be amended. If Stage 2 reveals that scope must widen or the map is wrong, stop the walk. Save progress. Mark the exit point. Preserve completed upstream work. Return to Stage 1 and amend the downstream map safely.

KSL and local agents

Frontier models can often hold the whole room. Small local models cannot. KSL makes limited-context agents useful by breaking the work into bounded Cards with required context, output contracts, purge rules, carried state, and receipts.

Local-agent version: a big task becomes a Spine; the Spine becomes Vertebrae; each Vertebra becomes small executable Cards; every Card exits with carried state and a receipt.

The hardening cycle

If the artifact is done but needs pressure testing, KSL it again. Break it. Surface the deficiency. Map the fix in Stage 1. Walk the hardening Spine in Stage 2. Verify the hardened artifact in Stage 3.

About the author

Corey J is an independent AI builder and systems designer focused on bounded AI workflows, deterministic tooling, local-agent execution, and practical methods that turn ambiguity into shippable work.

◆ Map the work. Walk the work. Verify the artifact. ◆