Glossary

The framework's working vocabulary, ingested and rendered verbatim. Every term of art on the site is one touch from its plain cut—the one-sentence definition with no term of art inside it. This is the index: each term links to its node page (§13), where the full entry opens by progressive depth, with its relationships and defining documents.

agent task (AT)

A precise, checkable spec an autonomous coding agent runs to do one bounded piece of work, halting rather than improvising when it meets a surprise.

arc

The full sequence of steps that carries a project from first idea to running system.

architectural register / executable register

The two levels a single thought is written at: the reasoning a person reads, and the exact instructions the executor follows.

Basis of Design

The one file that holds a project's settled design values as explicit numbers, the source of truth everything else builds from.

builds-on

A frontmatter field naming the upstream documents a piece of work depends on, so opening it pulls its context in order.

closure

The moment a unit of work and its look-back are finished and its status is marked done.

compressed chain

The chain of up-front framing documents when a seasoned practitioner has deliberately merged or skipped some of its layers.

constitutive child

A child unit of work that only makes sense alongside the parent it was split from.

dandori (段取り)

The preparation that turns a resolved plan into exact, runnable instructions before any building starts.

declared compression

Deliberately merging or skipping framing layers, but only when you write down what you combined and why, where the next session will see it.

design tuning

Settling a design's feel by building throwaway try-outs, watching real values move, and locking the ones that feel right.

devlog

A structured write-up done after a session that records what was decided and learned, so the work reads as yours rather than the machine's.

dogfood

Learning a tool by actually using it on a real task, the way a real user would.

eval (graded eval)

A human-graded check of output quality — correctness, clarity, judgment — where a pass/fail machine won't do.

forward-only

Finished work stays finished; a mistake is answered with a new document, never by editing the old one.

ha (破)

The middle stage where the practitioner breaks from the set form to scope and decide their own work.

ho (歩)

One bounded, deliverable session of work that leaves a record when it closes.

ho document

The written scope for one working session — its decisions, boundaries, and checks — read by the person doing the work.

ho overview

The build's directional plan, grouping the planned steps into themed clusters with checkpoints and named milestones.

ho-00

A project's first session, which sets up its conditions, primers, and conventions and passes to the first building step.

ho 0.5

The decimal slot for an unplanned step slipped in before the next major one.

ho-process/

The project folder that holds the methodology's working artifacts — the framing documents, the session records, and the task specs.

interaction test

A human at a real terminal checking that something works and feels right, not just that the code runs.

Kamae (構え)

The ready stance and all the framing done before a build, producing a chain of documents that move from opinions to a session plan.

Kamae addendum (kamae-N.M)

A follow-on decision document that overrides a named part of an earlier framing document without editing it, carrying its own justification and record.

kagen (加減)

The felt-right amount for a value — its correct degree, found by feel rather than by rule.

kokoroe (心得)

The built-in care an executing agent works under — read the context first, treat the spec as its authority, check by command, and stop and surface on surprise.

landing ho

A session whose whole job is settling visual or behavioral values at their felt-right degree and locking them with a commit.

learning walkthrough

A plain-language, after-the-fact walk through what a session actually built, written for the practitioner as learner.

mind / hand

The core principle of splitting one idea into its thinking (the mind) and its doing (the hand), so the doing can be handed off cheaply.

mutability (living / frozen / sealed)

The scale of how much an artifact may change over its life — living (revised freely), frozen (changed only by override), or sealed (never again).

notes/

The folder where findings gathered before a session wait until some later session pulls them in.

orientation ho

A framing-only session — setting conditions, primers, and handoff — with no building work inside it.

parti

The single core idea a whole project is organized around, the reference every later decision is judged against.

phase

A named stage of work, used at three scales — the whole project's progression, a cluster of related sessions, and the steps within a single session.

precedential thinking

Studying what already exists in a problem space before proposing to build anything new in it.

propagation ledger

The running log of changes to the settled values, each commit naming why the value moved.

Reflect

The honest look back after the work: did the plan hold, what changed, what the next session carries.

register

In this framework, the word means the cognitive altitude a thought is written at, not a data structure.

release tag

A tagged commit marking the end of a build stage, forcing a done/not-done call and leaving a rollback point.

replan checkpoint

A named pause in the plan where the practitioner stops, weighs real evidence, and decides whether to continue, insert, or rethink.

ri (離)

The stage where the form has been so internalized the practitioner moves past it, working from mastery rather than rules.

seed

The founding document that states a project's problem, vision, constraints, and guiding idea, revised deliberately as it evolves.

shape

The structural form a session document takes, chosen at authoring time, describing the document rather than the person.

shu (守)

The beginner stage of following a prescribed form exactly, before earning the judgment to depart from it.

shu-ha-ri (守破離)

The three-stage path of mastery — follow the form, break from it deliberately, then transcend it — held separately for each skill.

sidecar

A record kept in a sibling folder outside a fork's working tree, so your own process files never mix into someone else's repository.

sidequest

A bounded, detachable line of work inside a project, with its own folder, numbering, and its own check that it worked.

smoke test

An agent walking through the real feature to confirm it works — the floor other checks must clear, never the final word.

spike (design)

A purpose-built proof that a design's settled values hold up against real code constraints, made as the reference the production build copies from.

splits-from

A frontmatter field on a session carved out of an oversized one, pointing back at the original it was divided from.

standalone agent task

A self-contained agent task that belongs to no larger session — maintenance, a surgical fix, or early exploration.

supersedes

Names exactly what a newer document overtakes; the older one keeps a pointer back, and nothing is erased.

Think / Execute / Reflect

The fixed three-part rhythm of a building session — decide first, build second, then judge honestly what happened.

tiered understanding

Naming honestly how well you grasp something, on a three-step scale from use-it-blindly to could-rebuild-it.

tripwired

Built to run on its own within set bounds but stop and raise a flag the instant it meets something unexpected.

tuner

A live control that lets you move a visual or behavioral value and watch it change before committing to a number.

verification / validation

The two halves of quality — verification asks whether it was built right, validation asks whether the right thing was built and whether it's any good.