problem
Files in folders were an accident of storage, not a model of software. Most API surfaces sit where a file happened to end or a team happened to split — and our diffs measure bytes moved, not meaning changed.
~/projects/unfiledunfiled.sudoscience.dev →
Unfiled
prototype# 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. The folder tree is demoted to a projection. Diffs become semantic.
thesis
When agents write most of the code, the human contribution is intent — and intent must be stated declaratively or it cannot be delegated. Speech that says what it means pushes boundaries to the semantic edge: the command, the event, the scenario. The repo becomes one rendering of the graph among several.
top-level constructs
things that stop living inside files
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.
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 addressable independent of its import path.
Event Modeling constructs
Swimlanes, slices, and timelines as durable design objects, not whiteboard photos.
C4 constructs
Context, container, component — the architecture graph kept live and linked to the code it describes.
Decision
Why a boundary sits where it sits, attached to the boundary itself.
Named Entity
A repo-level glossary: constructs get stable identities, and human names become metadata overlaid in the editor. A rename is a glossary edit, not a refactor — and tools recognize and enrich every reference.
semantic change
diff the meaning, not the bytes
change sets over constructs
"Renamed PlaceOrder's timeout parameter and tightened its type" — not forty lines of churn because an import moved. In the spirit of opral/lix.
identity survives motion
Content-addressed constructs (the Unison move) make moving code a no-op and renaming metadata. Review attention goes to behavior only.
history as a graph query
"When did this boundary last move, and which decision moved it?" stops being commit-message archaeology.
coverage over intent
Stories link to the constructs that implement them and the tests that constrain them — so coverage is measured against scope, not lines. "Which requirements have no tests" becomes a query.
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
Code lived in the system, not in files — the original everything-is-an-object workspace.
tree-sitter / Difftastic
Structural parsing and AST-aware diffing as the practical on-ramp from text.
artifacts
status, honestly
thesislive
unfiled.sudoscience.dev
construct schemasketch
constructs, edges, changes, decisions as a typed vocabulary
given/when/then workflow DSLprototype
branchable scenarios as executable constructs, from the agentic workflow cookbook — a Scenario is a claim you can run, and the same claims enforce parity across two execution engines
prior-art corpussketch
the field above, filed: graph-based code modeling, moldable development, language workbenches, code-query systems, Unison, lix — captured into a typed concept ontology by the same research run that seeded Rhett. The prior-art section is the visible tip
projection to filesroadmap
render the graph to a conventional repo so toolchains keep working
edges
connected investigations
absorbed prior work — named, never shipped, not available
Sgittish
The repo-level object store draft: code as data in an append-only ledger, Functions addressed by checksum, invocation histories that become test cases. Unfiled is Sgittish with the boundaries argument in front.
Cogent
Optic's component-driven code generation: units of code as React components rendered by a filesystem-oriented renderer, with changelog-aware SDK generation that wouldn't break clients. Generation as projection — the move Unfiled makes for everything.
Spectacle
Optic's query layer over API descriptions: one GraphQL surface regardless of how the spec was represented underneath. The same trick Unfiled plays on codebases.
the changelog spec
Optic's event-sourced spec format: each change semantic and unambiguous ("did that key get renamed, or removed and re-added?"), attributed to a person, replayable into any version. Semantic diffs, shipped once already.
Say what you mean; let the boundaries follow. It started as the Sgittish draft and an "append-only object store on top of Git" experiment — the AI wave didn't create the idea, it created the audience.