I need a structure that survives when the tools change.

Ch. 01 What it is

Tools come and go — the model you used last year, the note app you swore by, the agent framework that was hot in spring. What outlives all of them is where your work lives and how it's organized. A folder spine — plain files, named by what they're for, with a map at the top — is the one layer you never have to rebuild. Three depths, simplest first: a clean folder map, then a routing layer that tells an agent where to look, then the full operating structure an agent runs the business from.

Ch. 02 The three ways to build it

Simplest path first. Every tier carries its real setup time and its honest trade-off — the cost is the part most write-ups leave out.

1
Tier 1 · simplest path
A clean folder map
Setup~15 min
- plain folders
- markdown
Start with folders and one file. Group the work by what it's *for*, not by what tool made it — `revenue/`, `delivery/`, `content/`, not `notion-exports/` and `chatgpt-stuff/`. Number the stages of anything that runs in order (`01_intake`, `02_build`, `03_ship`) so the sequence is visible without opening a thing. Then write one map at the top — a single file that says, in a sentence each, what every folder holds and where a given job belongs. That map is the whole mechanism. Anyone — you in six months, a new tool, a person you hand it to — reads it once and knows where everything lives.
The trade-off
Plain folders look too simple to be the answer, and that's exactly why they last. There is nothing to migrate when you switch tools, nothing locked in a format you'll lose access to, and you can read the entire structure at a glance. The honest ceiling: a flat map stops being enough once the work spans many parallel tracks and the map itself grows long enough that you stop reading it. That's the signal to add the routing layer, not before.
2
Tier 2
The routing layer
Setup~1 hr
- markdown
- context files
Promote the single map into a routing layer. At each level, a small context file points down to the next — the top map names the folders, each folder's own map names what's inside it and which file answers which kind of question. Now structure isn't just for you; it's instructions an agent reads before it acts. Ask it to draft an offer email and it walks the routing files to the offer folder instead of guessing or inventing. The files stay plain markdown, so you own them outright, you can read them without any tool, and the day you change models or apps the structure doesn't move an inch.
The trade-off
Routing files only help if they stay true. A pointer to a folder you renamed, or a map describing a structure you reorganized last week, sends the agent confidently to the wrong place — worse than no map, because it reads as authority. The upkeep is real: when the structure changes, the maps change in the same pass. Keep them short. A routing file that grows into a second copy of the work has stopped routing and started rotting.
3
Tier 3
The full operating structure
Setup~half day+
- markdown context layer
- an agent runtime
At full depth the folder spine becomes the operating structure an agent runs the business from. The maps don't just describe where things are — they encode how work moves: a job enters one folder, the rules there route it to the next, decisions get written down where the next run will read them, and the agent navigates the whole thing by following the structure rather than holding it in its head. This is the layer that lets you point an agent at the business and have it find its way around without you in the loop. It earns its complexity only when there's real, recurring, multi-part work for it to carry — and it's the one depth where the structure is doing the operating, not just the filing.
The trade-off
This is genuinely more to build and to maintain, and it's wasted on a business that doesn't yet have repeating work to route. Encode rules the structure can't actually enforce and an agent will follow a path that no longer matches reality. Don't reach for the full operating structure until Depths 1 and 2 are visibly straining — until the routing layer can no longer carry the volume and the hand-offs have become the bottleneck. Most one-person businesses live happily at Depth 2 for a long time; climb only when the lighter version breaks.

Ch. 03 The detail

Tools come and go — the model you used last year, the note app you swore by, the agent framework that was hot in spring. What outlives all of them is where your work lives and how it's organized. A folder spine — plain files, named by what they're for, with a map at the top — is the one layer you never have to rebuild. Three depths, simplest first: a clean folder map, then a routing layer that tells an agent where to look, then the full operating structure an agent runs the business from.

Category: Foundations · Structural substrate
Format: System
Level: foundational
Provenance: Own-packaged

foundationsfoldersstructurecontextagentsmarkdown

The layer that outlives the tools

Pick any tool you depend on today and run the clock forward two years. The model has a new name and a different price. The note app got bought and the export is messy. The agent framework everyone was using in spring is a footnote by autumn. Almost everything in a one-person tech stack has a short half-life — that’s the nature of the thing.

One layer doesn’t. Where your work lives, and how it’s organized, survives every tool you’ll ever swap. Folders named by what they’re for, files in plain text, a map at the top that says what goes where — none of that depends on a vendor staying in business or a model staying current. When you change tools, the structure doesn’t move. You point the new thing at the same folders and it finds its way around, because the organization was never in the tool. It was underneath it.

That’s the bet this entry makes: build the structure first, and treat the tools as things that plug into it and unplug from it. Most people do the reverse — they let whatever app they’re using dictate how their work is shaped, then have to reshape everything the day they leave. Get the order right and the migrations stop hurting.

Start at the shallowest depth

The instinct is to skip to the agentic version, because a structure an agent operates sounds like the serious answer. On a young business it’s the wrong one — you spend an afternoon encoding routing rules for work that doesn’t recur yet, when a single map you read top-to-bottom would have held everything. Depth 1 wins more often than it looks like it should, precisely because you can see the whole structure at once and there’s nothing to get out of sync.

Climb only when a depth visibly strains. Depth 2 earns its place when the work splits across enough parallel tracks that one flat map grows too long to actually read — that’s when the routing layer pays for itself. Depth 3 earns its place when there’s real recurring work for the structure to carry, not just describe — when an agent should be navigating the business on its own and the hand-offs between steps have become the thing slowing you down. Each rung trades a clear benefit for a clear cost, and the cost is written into the trade-off block on every tier, because the cost is the part most “just use this tool” advice leaves out.

The honest version

There’s no structure that maintains itself for free. The shallow depths ask almost nothing of you — name things well, keep one map honest. The deep one automates the navigation but pays for it in upkeep: every time the work reorganizes, the maps have to reorganize in the same pass, or they quietly start lying. A map that describes a structure you changed last week is worse than no map at all, because an agent reads it as truth and walks confidently to the wrong place.

So pick the lightest depth that survives your actual workload, and move up only when it breaks — not before. The whole point of building on structure instead of tools is that you stop rebuilding from scratch every time the landscape shifts. A folder spine, kept honest, is the closest thing a one-person business has to a foundation that doesn’t need pouring twice.