Your Files Are Dead. Here's What Comes Next.

Andrej Karpathy described the large language model not as a chatbot but as a new kind of operating system: one where context is memory, tokens are compute, and the files you feed it are the programs it runs.

If that framing is right, then most of the documents your organization produces right now are broken software. Not because they're poorly written. Because they were designed for the wrong reader.

The document was built for humans

Every document convention we have, the executive summary, the table of contents, the footnote, the appendix, exists because of human cognitive constraints. We skim. We lose our place. We need repetition to retain. We read linearly.

AI doesn't have any of those constraints. And it has a completely different one we almost never design for: the context window.

A language model reads your file the way a spotlight reads a stage. It can only see what fits inside the beam. Feed it a 40-page SOW and it's working with a compressed, truncated, lossy version of what you wrote. The formatting you spent hours on? Mostly noise. The careful narrative arc? The model doesn't care. What it needs is density, structure, and signal, and most documents deliver almost none of that.

We've been writing files for humans and then wondering why AI outputs feel shallow.

Living files: the new primitive

A living file isn't a document. It's a knowledge object designed to be consumed, updated, and re-consumed by AI systems over time.

The difference isn't cosmetic. It's architectural.

A static document captures a moment. A living file tracks state. It knows what it is, what's changed, what decisions have been made, and what context the reader, human or AI, needs to get current fast. It's less like a report and more like a codebase: versioned, modular, and continuously maintained.

Karpathy's LLM wiki on GitHub gestures at this. It's not a blog. It's not a README. It's a structured knowledge base built to be read by a model as much as by a person, where headers are navigation, sections are semantic units, and the whole thing is optimized to transfer maximum understanding in minimum tokens.

That's the design principle most organizations haven't found yet.

Expansion and elasticity

One of the most useful properties of an AI-native file is elasticity: the ability to expand or compress based on the context it's being used in.

Sometimes you need the full picture: complete history, all the nuance, every caveat. Other times you just need the current state, the three key facts, the decision that was made. A static document can't serve both needs without creating two documents and managing the drift between them.

A living file solves this with layered architecture. The top layer is dense summary: the compressed context. Beneath it are expansion blocks that a model or a human can pull when they need depth. The file can be read at multiple resolutions.

This isn't a new idea in software. It's how APIs work. Request what you need, get back what's relevant. We just haven't applied it to knowledge files yet.

The practical version:

• A three-sentence context block at the top of every file: what this is, why it exists, current status
• Modular sections that can be included or excluded based on the use case
• A changelog block tracking material updates so an AI can quickly determine whether it has current context
• A compression note signaling token weight, letting an orchestration layer decide how much of the file to load

Elastic files don't bloat the context window. They load at the right resolution for the task.

Token optimization is the new information architecture

Every word in a file costs something. In an AI-native workflow, that cost is real: tokens consumed in context are tokens unavailable for reasoning, output, or other documents in a multi-file system.

Token optimization isn't about making things shorter. It's about maximizing signal per token.

That means:

Front-loading meaning. The most important information should appear first, not buried three paragraphs in. AI models weight early context more heavily.

Eliminating decorative language. Transition phrases, hedging language, and filler sentences add friction for AI processing. Cut them.

Structured formats over prose where possible. Bullets, key-value pairs, and headers are cheaper to parse than narrative paragraphs when the goal is information retrieval, not persuasion.

Naming things explicitly. Vague pronoun references and assumed shared context are ambiguity tax. AI systems resolve ambiguity by hallucinating. Explicit nouns, dates, and identifiers prevent that.

Semantics over syntax. A file optimized for a model uses language the way a database uses schema: every term is precise, consistent, and refers to exactly one thing.

None of this makes the file worse for human readers. In most cases it makes it significantly better.

AI-native files are a competitive asset

The teams that get the best results from AI workflows aren't the ones with the best models. They're the ones with the best context.

Context is your institutional knowledge: SOPs, brand standards, customer data, decision history, formatted in a way AI can actually use. Organizations that invest in that infrastructure now are building a compounding advantage. Every well-structured file makes every future AI interaction better.

Organizations that don't are feeding their most expensive tool a diet of PDFs, slide decks, and email threads and wondering why the outputs need so much editing.

The shift to AI-native files isn't a formatting preference. It's a knowledge infrastructure decision. Most organizations haven't made it deliberately yet, which means the window to get ahead of it is still open.

What to do with this

Start with the files that feed your AI workflows most frequently: brand guidelines, product specs, customer personas, process documentation. Ask: is this file designed to be read by a model? Does it have a compression layer? Is it elastic? Is it current?

If the answer is no, that's where to start.

The organizations treating knowledge files as living infrastructure, not static deliverables, are going to have a real advantage as AI becomes the primary way work gets done. The gap between them and everyone else is opening now.