Why Your AI Context Should Live in a Plain Text File (Markdown, Explained)

Somewhere between deciding to give AI real context and actually doing it, people hit a strange little question. What kind of file is this supposed to be?

A Word document feels official. A Google Doc is where everything else lives. A PDF looks finished. The memory panel inside ChatGPT is right there and requires no file at all. And the advice from people who build with AI every day keeps saying something that sounds almost too plain to be right: use a text file.

They're right. Here's why, and what that file should look like.

What's the best format for AI context?

Plain text, and usually Markdown. It's the only format every AI tool reads without conversion. Headings and lists give it structure a model can follow, and it opens in any editor on any computer, including ones that haven't been built yet. You own the file, so you control what it says and where it goes.

Markdown isn't a separate file type so much as a few conventions on top of plain text. A pound sign makes a heading. A dash makes a list item. That's most of it.

Here's how it stacks up against the places people usually put their context.

The pattern along the bottom row is the whole argument. Every other format is either owned by a tool or built to be looked at. Plain text is the one built to be read, by people and models alike.

Why do AI models handle Markdown so well?

Because the structure is in the text itself. There's no hidden formatting layer for the model to strip away, and nothing to guess at.

Consider what a heading actually does. It's a label. When your file has a section called How I write and another called What I'm working on, the model knows where your voice rules end and your current projects begin. A bulleted list does the same job at a smaller scale. It turns a paragraph of preferences into separate rules the model can follow one at a time.

You don't have to take that on faith. OpenAI's prompting guide for GPT-4.1 recommends Markdown as the place to start, "using markdown titles for major sections and subsections," with standard numbered or bulleted lists as needed. Anthropic's documentation for Claude Code gives nearly the same advice for its instruction files: "group related instructions under markdown headers and bullets. Organized sections are easier for Claude to follow than dense paragraphs."

Two of the biggest model makers, describing their own systems, landed in the same spot.

The builders already decided this

Developers settled the format question a while ago, and they settled it on plain text.

Claude Code reads its standing instructions from CLAUDE.md files. Anthropic's docs call them "markdown files" and put it simply: "You write these files in plain text." A cross-tool standard called AGENTS.md, supported by coding agents from OpenAI, Google, and others, describes itself as "just standard Markdown" and reports use in more than 60,000 open-source projects. When people need an AI to act on instructions reliably, day after day, they don't reach for a slide deck. They write a text file.

You don't need to be a developer to borrow the lesson. The same file that tells a coding agent how a project works can tell any assistant how you work. We covered the agent side of this in how to give an AI agent context. The format is the same either way.

Why not just let the memory feature handle it?

Built-in memory is convenient, and it's fine for small things. But it's written by the tool, stored in the tool's account, and readable only by that tool. You can review it and delete it (here's how, for all three), but you can't carry it next door.

A text file flips every one of those. You write it. You store it. Every model reads it. And when you switch assistants, moving your context is a paste instead of a year of retraining.

The thing is, you don't have to choose. Let memory handle the small conveniences, and let the file hold the real copy.

What does a good AI context file look like?

Short, dated, and sorted under headings. Here's the shape, using a made-up freelance garden designer:

# About me (updated 2026-10-28)

## Who I am
- Freelance garden designer, mostly residential yards
- I care more about plants that survive than plants that photograph well

## How I work
- Give me options, then a recommendation
- Flag cost or maintenance problems up front

## How I write
- Plain, friendly, short sentences
- Never: "elevate," "curated," "oasis"

## What's true right now
- Booked through spring; not taking new installs until April
- Building a small online course on dry-climate planting

## Never
- Don't invent plant facts. Say when you're unsure.

Every line is something a model can act on. Nothing is decoration. And the date at the top tells the model this is a snapshot, true as of a moment, rather than a permanent fact.

What goes in those sections is its own question, and a bigger one. This post covers it. Many people outgrow one file and split it into several, one per topic, so they can update the part that changed without touching the rest. If those files feed agents, here's how to split them so each agent loads only what it needs. At RUMO those pieces are called context anchors.

How do you keep a plain text file current?

This is where plain text quietly earns its keep.

Keep one original and treat everything else as a copy. When something changes, edit the file first, change the date, then refresh the custom instructions and projects that hold older versions. Two months of edits made directly in three different tools is how you end up with three descriptions of three slightly different people.

Plain text also makes changes visible. Save a dated copy before a big rewrite, or keep the file in a synced folder with version history, and you can see exactly which lines moved. That's hard to do with a memory panel and awkward with a PDF.

How often to refresh is its own discipline. This guide breaks it down layer by layer.

Where should the file live?

Anywhere you control that saves plain text. A synced folder. A notes app that stores notes as Markdown files on your own drive, like Obsidian. Even TextEdit or Notepad, set to plain text, will do. Name it something obvious, like about-me.md, and keep it one click away, because you'll paste it often.

The format that outlives the tools

AI tools change their menus every few months, and their memory features with them. The model you rely on this year will be retired. The assistant you use next year may not exist yet.

A text file doesn't care. Text files from decades ago still open in whatever editor you have today, and the one you write this week will open in whatever tool replaces all of these.

So write it once, in plain text, and keep it. The easiest first section is the deepest one: what you value and how you make decisions. The free Personal Constitution builder walks you through it in about thirty minutes and hands you the result as a file you own.