rm -rf src/

Unfiled

Code is a graph, not a filesystem.

The current disruption is a forcing function: to delegate work you must say what you mean, declaratively and intentionally — and once you do, API boundaries move to where they should have been all along. Functions, tests, scenarios, commands, events, components, and architecture become top-level constructs. Diffs become semantic.

The constructs Semantic diffs

one change, three nodes

change cs_4821 {
  Scenario  "guest checkout"     ~ extended
  Command   PlaceOrder           ~ timeout: 500ms → 200ms
  Component <CheckoutButton/>    ~ new state: "confirming"

  edges: Scenario → Command → Component
  decision: "checkout latency is a boundary now"
}

Files in folders were an accident of storage, not a model of software. The model was always a graph.

When agents write most of the code, the human contribution is intent — and intent must be said declaratively or it cannot be delegated.

API boundaries follow the honesty of speech. Say precisely what a thing is for, and the boundary lands where it always should have been.

Forcing function

Disruption pushes boundaries to where speech is honest.

Disruption as forcing function

Agents make the cost of restructuring collapse, and they make vague instructions fail loudly. Both pressures point the same direction: toward saying what you mean, in constructs a machine can hold you to.

Declarative, intentional speech

An instruction like "make the checkout faster" is a wish. "The PlaceOrder command must emit OrderPlaced within 200ms at p99" is a contract. The second one is speech that can become a boundary.

Boundaries move to where they belonged

Most API surfaces sit where a file happened to end or a team happened to split. When intent is the unit of contribution, the seam moves to the semantic edge — the command, the event, the scenario — and stays there.

The repo becomes a projection

Files don't disappear; they become one rendering of the graph among several — like a table is one rendering of a query. The graph is the source of truth; the folder tree is a view.

Top-level constructs

Things that deserve to stop living inside files.

Each one addressable, versioned, linkable — nodes in one graph, with the folder tree demoted to a rendering.

Function

A named, typed, addressable unit of behavior — not line 214 of utils.ts.

Test

A claim about behavior, linked to the construct it constrains, not a parallel folder tree.

Scenario

A given/when/then path through the system, executable and citable.

Command / Event / Read model

The CQRS/ES triad as first-class objects: intent in, facts out, views derived.

React Component

An interface contract with props, states, and renders — addressable independent of its import path.

Event Modeling constructs

Swimlanes, slices, and timelines from eventmodeling.org as durable design objects, not whiteboard photos.

C4 constructs

Context, container, component — the architecture graph kept live and linked to the code graph it describes.

Decision

Why a boundary sits where it sits, attached to the boundary itself.

Semantic change

Diff the meaning, not the bytes.

Semantic, not textual

A diff should say "renamed PlaceOrder's timeout parameter and tightened its type" — not show forty lines of churn because an import moved. Change sets over constructs, in the spirit of opral/lix.

Identity survives motion

Content-addressed and identity-tracked constructs (the Unison move) mean moving code is a no-op and renaming is metadata. Review attention goes to behavior changes only.

Review at the right altitude

A change touches three constructs: a scenario, the command it exercises, and one component. The review is those three objects and their edges — not a 19-file diff.

History as a queryable graph

"When did this boundary last move, and which decision moved it?" becomes a query, not an archaeology session through commit messages.

Prior art

The pieces exist. The graph doesn't — yet.

opral/lix

A change-control SDK where changes are semantic entities, not text hunks.

Unison

Content-addressed functions; names are metadata; the codebase is a database.

Smalltalk images

The original everything-is-an-object workspace — code lived in the system, not in files.

tree-sitter / Difftastic

Structural parsing and AST-aware diffing as the practical on-ramp from text.

eventmodeling.org

A complete-system notation whose constructs deserve to outlive the whiteboard.

C4 model

Architecture as a small set of typed, nested constructs — already a graph, usually stranded in a wiki.

Status

Thesis stated. Substrate next.

thesis

Drafted — this page.

construct schema

Sketch — a minimal typed vocabulary for the graph: constructs, edges, changes, decisions.

projection to files

Roadmap — render the graph to a conventional repo so existing toolchains keep working while the boundary moves.