Log inSign up

The folder is the agent.

You don't build an AI system. You write a folder.

Credit where it's due

The phrase comes from Kieran Klaassen, GM of Cora at Every. He put a name to something a lot of us had been feeling in April 2026. His line, worth quoting:

Once you realize the folder is the agent, you can run as many as you want.

Klaassen's essay describes his own setup — a folder with a CLAUDE.md, some developer docs, some investigation notes, a few specialists defined in .claude/agents/. Point a model at the folder and it's a Rails engineer. Point it at a different folder and it's an ops engineer. The folder is the agent. He runs forty-four of them.

This page builds on that. Klaassen wrote the engineer's version. The bigger version is that the folder idiom isn't just for developers — it's the way to build any repeatable AI system, for anyone. And once you've seen it, you don't go back to prompts.

The inversion

For most of the last decade, building a software system has meant writing code. Code is the asset; text is the explanation around the code.

AI flips that. Text is the asset. Code is the plumbing that delivers it to a model. Your runbook, your context, your examples, your standards — these are what the AI actually uses. A framework is a wrapper. A UI is a scaffold. The real thing is a folder of markdown files that any capable model can read and act on.

This is the part people keep missing. They look at “write your agent in markdown” and assume it's a toy — a shallow wrapper over what should really be code. It's the other way around. The markdown is the contract. The code is the tool that gets a model to honor it.

The Terraform moment

We've been here before.

Twenty years ago, if you wanted a server, you logged into the AWS console and clicked through twelve screens. You remembered where you clicked. You hoped nobody un-clicked it. When someone new joined, they learned the clicks from you, over a call, over Zoom before Zoom existed.

Then Terraform happened. You stopped clicking. You wrote what you wanted in a file. The tool figured out how to deliver it. The file became the source of truth. The infrastructure became a consequence of the file.

The file was better than the clicks for a handful of specific reasons. You could put it in version control. You could diff it. You could review it. You could email it to a coworker. You could re-run it tomorrow and get the same thing. You didn't need the tool running to read it and understand what the system was supposed to do.

AI is having its Terraform moment. The action is moving from clicking through Claude's web UI — or from gluing together an orchestration framework — into a folder of markdown files. The file is becoming the source of truth. Everything else is a consequence.

This isn't a niche developer thing. The MKT1 newsletter profiled four marketers — an ICP strategist, a growth lead, a product marketer, and an agency owner — running their marketing operations out of markdown folders. Emily Kramer, Elaine Zelby, Aditya Vempaty, Kamil Rextin. Not engineers. Their folders contain ICPs, personas, messaging frameworks, voice guidelines, launch templates. They run their day out of those folders the same way an engineer runs a deploy out of a main.tf. Same shift. Different audience.

Karpathy's LLM Wiki gist from April 2026 made the technical case: for personal knowledge bases, a folder of markdown files maintained by an LLM beats vector databases and retrieval infrastructure. The file system is the database. The folder is the context. The agent is what happens when a model reads it.

Same shift.

What a folder gives you that a framework can't

1. Version control

Your agent's behavior has a git log. When it starts misbehaving, you look at what changed. When you want to try something, you branch. A bad change is a revert away. The person who touched the brand voice guide last Tuesday is in the commit history.

No framework gives you this for free, because no framework puts the behavior in a file in the first place.

2. Portability

Your runbook works on Claude today. It works on GPT today. It works on Gemini today. It'll work on whatever ships next quarter. Anthropic published Agent Skills as an open cross-platform standard specifically because this property is load-bearing. Cloudflare's blog post Markdown for Agents makes the same argument: markdown is the lingua franca for agents precisely because nothing else has consensus.

Tools churn. Markdown doesn't.

3. Review

Your team PRs changes to the agent the same way they PR code. The marketing director reviews the brand voice. The lawyer reviews the compliance clause. The head of customer support reviews the tone rules. Each person edits the part they own. Nobody has to understand the whole system to contribute a line to it.

This is how organizations actually work. A framework breaks it; a folder honors it.

4. No runtime

You can read it. You can print it. You can email it to a coworker. You can open it in Obsidian or TextEdit or Vim or nothing at all. It still works. It works because markdown is a medium of communication, not an execution artifact. A human can tell what it does. The AI can tell what it does. Nobody needs to install anything first.

The honest objection

The strongest skeptic has a point. Cordero Core wrote an essay called “Your CLAUDE.md is making your agent dumber.” His line: “The model wasn't broken. I was feeding it a map of a city that didn't exist anymore.”

He's right. A folder can lie. It describes what you wrote down, not what's currently true. Left alone long enough, it drifts out of sync with reality. The agent starts looking at the map and ignoring the terrain.

This is the honest counter-argument and it deserves a direct response.

The folder is the spec, not the state. It says what good looks like. It does not say what's true about the world right now. That's a different job, and it's the one Jetty does.

When you run a runbook, Jetty goes looking for what's actually happening. The agent reads the folder, does the task, and — crucially — checks its own work against the standards in the folder. When the work doesn't match, the agent iterates. When the folder is out of date, the checks start failing. You see it. You update the folder. The folder stays honest because every run is a chance to falsify it.

This is the part of the puzzle Klaassen gestured at and the part Jetty makes explicit: the folder is the noun, the runbook is the verb. The folder is what the agent reads. The runbook is what makes the folder stay honest. Without the second half, you have a map of a city that doesn't exist anymore. With it, you have a map that updates itself when the city changes.

What this looks like for you

Whichever audience you arrived here from, the translation is the same:

  • If you're an operator (a marketer, an analyst, an ops lead): your personal AI setup — the skills, the prompts, the custom GPTs — already is a folder, even if it's scattered across tools. Organize it. Write down what “done” looks like. Run it through Jetty. You now have an AI operating system for your work.
  • If you're a team lead: your team's shared AI setup should be a folder too. One runbook per workflow. One library per team. Shared, reviewed, versioned. Read for-teams.
  • If you're a builder: you already knew. Stop fighting it. Your agents are markdown. Let them be markdown. Read for-builders.

Ready to try one?

Write your first runbook →

Start with a folder. One file. One task. See what happens when you run it.

Read: What is a runbook? →

The specifics of how the folder becomes a runnable thing.

Sources and further reading