Your First Standing Config

For three lessons you have been the reader. This lesson you become the operator.

You already know the mental model: AI is not a tool you query and walk away from — it is an operating system, and the operators pulling real leverage build architecture around the model instead of just using the model. You know the six-layer stack. You know that intent routing before the first word is the highest-leverage habit there is.

Now you write the first piece of that architecture to disk. Not a thought experiment — a real file, on your machine, in about fifteen minutes.

What a Standing Config Actually Is

In the “AI Is Not a Tool. It Is an Operating System.” lesson, standing configuration was one of the layers of the operator stack — the persistent state that loads before every session instead of after you remember to re-explain something. The canonical file is CLAUDE.md.

Strip away the mystique and it is just a text file in your project that the AI reads automatically every time you start working there. Whatever you put in it becomes context the model already has — before you type a single prompt. That is the entire idea: write your context down once, and stop paying to restate it.

A minimal standing config has four load-bearing parts. Each one is a category of context you would otherwise re-type, session after session.

Notice what every part has in common: it is concrete. Not "dark theme" but #0d1117. Not "don't break things" but "never commit to main." The reason is simple — the model acts on what you actually wrote, not on what you meant. Vague input produces drift; specific input produces obedience.

The Tax You Are About to Stop Paying

Here is the failure mode a standing config kills. Without one, every session begins with you re-explaining who you are, what the project is, and what the constraints are. At five sessions a day, you pay that re-explanation tax five times a day, every day. It never compounds — each session is a cold start.

The fix is not to type faster or remember better. It is to move that context out of your head and into a file the system loads for you.

Look at the two columns. The effort is identical — the same words about the same project. The only difference is direction: the ad-hoc operator spends those words into the void at the start of every session; the standing-config operator spends them once, into a file, and every future session inherits them.

That is the shift from using AI to running it as infrastructure, expressed in the smallest possible artifact.

The Routing Line — Your First Automatic Decision

Three of the four sections capture context. The fourth does something different: it automates a decision.

Intent routing was the highest-leverage habit in the “AI Is Not a Tool. It Is an Operating System.” lesson — classifying a task by type and sending it to the model optimized for that type, before you begin. The problem with a good habit is that you have to remember to do it. A standing config removes the remembering.

One line does it:

Reasoning / architecture / tricky debugging  ->  deep model
Fast edits / boilerplate / known-pattern synthesis  ->  fast model

Now routing is not a decision you re-make every task. It is a written default that you and the agent follow without re-deciding. You route before the first prompt because the rule is already on the page — the line itself does not switch models for you (automated cross-model routing is the grown-up classifier version you meet later), but it removes the remembering and makes the right choice the obvious one. That single line is the difference between routing as a discipline you occasionally remember and routing as a standing default that is always there to apply.

The standing config is the planning made permanent. Each individual session is a plan — useful now, gone after. The file is the planning discipline that makes every future session start warm.

Build It Now — The Fifteen-Minute Version

Enough theory. You are going to write a real CLAUDE.md from the template below. Do not over-engineer it. The whole file should fit on one screen.

The five steps:

1. Make a project folder. Any real or practice project — a portfolio site, a script, anything. mkdir my-project && cd my-project.
2. Create CLAUDE.md in that folder. (touch CLAUDE.md, or just open it in your editor.)
3. Fill the four sections from the template: identity, conventions, one rule, one routing line. Concrete values only — the moment you reach for an adjective, replace it with a specific value.
4. Save it. That is your first piece of standing infrastructure on disk.
5. Start a session in that folder and ask the model: "Read CLAUDE.md and tell me, in your own words, the project context and the rules you must follow." If it plays your context back correctly, the config works.

The challenge below is that template, with the quality bar built in. Fill each section so a model could act on it without a single follow-up question.

Why This Small File Is the Whole Game in Miniature

It is tempting to dismiss a four-section text file as trivial. It is not — it is the operator pattern at the smallest possible scale.

The same discipline you just practiced is exactly what scales up. The memory layers later in the Academy are standing config that persists across projects, not just sessions. The agent fleets are standing config that tells autonomous processes how to behave when you are asleep. The routing logic in a production system is your one-line routing rule, grown into a classifier. Every layer of the operator stack is, structurally, what you just built: context and rules written down once so the system carries them for you.

Lesson Drill

Open the CLAUDE.md you just wrote and run the follow-up test on every single line: could a model act on this without asking me anything? Find the weakest line — the one with an adjective doing work a value should do — and rewrite it concretely. ("Modern design" becomes a palette. "Be careful with git" becomes "never commit to main.")

Then add exactly one more line to your routing section: pick a third task type you actually do (real-time search, image generation, long-context synthesis) and route it to its tier. You are now maintaining a standing config — which is the operator's daily habit, not a one-time setup.

Bottom Line

A standing config is the smallest piece of AI infrastructure you can own, and you can write your first one in fifteen minutes. Four sections — identity, conventions, one enforced rule, one routing line — and you have stopped re-explaining yourself every session. The rule for every line is the same: concrete enough that a model could act on it without a follow-up.

This is where the operator mindset stops being something you read about and becomes something you do. You have shipped your first standing config. Next, you install Claude Code and ship your first project on top of it.