Writing Culture Is Back. But Not For Us. Here's Why Leaving Notion Means Something Bigger.

For the past fifteen years in product management, I have watched the same pendulum swing back and forth. On one side, the gut-led stance: small teams, two-pizza rules, fast verbal communication, decisions made on a whiteboard with everyone in the same room. On the other side, the systematic stance: companies preparing for scale, treating writing as the substrate of thinking. The six-pager at Amazon. The GitHub Issue at Alan. The written decision at Stripe.

Both sides were correct, depending on the size of the company you were running. The pendulum was a choice.

Something is changing.

It is not changing because we are moving toward more writing. It is changing because the reader has changed. And so has the writer. I have never written as much documentation as I am writing right now.

Something is changing.

I am considering leaving Notion. Two months ago, I left Figma aside.

Something is changing.

Andrej Karpathy caught it on stage at Sequoia AI Ascent in April. He calls the new era Software 3.0. His framing of why is the cleanest one I have heard. LLMs, he said, are not animal intelligences. They are statistical simulation circuits whose substrate is pre-training. Ghosts, not animals. Ghosts shaped by documents.

If your agent is a ghost shaped by documents, then the documents you write are the body it inhabits. A Notion page locked behind SSO is bones the ghost cannot find. A markdown file at the root of your repository is a body the ghost steps into.

Two months ago we deleted our Figma boards and downgraded our subscription. Our design system moved into the codebase, version-controlled with the rest of the platform. Last month we started deleting our Notion pages. Our specs, standards, and decision logs are moving the same way. Both migrations looked like productivity decisions at the time. They were actually the same decision, made twice. Our agents could not read the previous tool.

This is the part of the story most analysis is getting wrong.

The Misdiagnosis

The conventional reading of what is happening to documentation tools is that AI killed them. The wikis are dead. Notion is dead. Confluence is dead. Knowledge management was a process tax we paid because humans had bad memory, and the agents are about to make all of it disappear.

This is wrong, and the wrongness matters because it leads founders to invest in the opposite of what works.

The medium did not die. The audience changed.

For twenty years, documentation served humans separated by time and distance. The cost was paid in human effort. The benefit was paid in human alignment. When the cost stopped feeling worth it for a small team, companies stopped writing. That move-fast era was rational while the audience was small enough to fit in a Slack channel.

Then a new reader walked into the room. The agent does not attend the standup. The agent does not rewatch the Loom. The agent does not have access to the DM where the real decision was made. The agent reads, or the agent guesses. There is no third option.

Software 3.0 did not abolish writing. It changed the reader. And once you change the reader, the medium has to follow.

The Old Era Was a Choice. The New Era Is Not.

The systematic stance produced the most admired companies of the era. On June 9, 2004, Jeff Bezos sent an internal email banning PowerPoint at Amazon and replaced slides with the six-page narrative memo, read silently for the first twenty minutes of every meeting. Andy Jassy reportedly wrote thirty drafts of the memo that became AWS. Brie Wolfson, who spent four years at Stripe, called the company "a celebration of the written word that happens to be incorporated in the state of Delaware." At Alan, decisions were made in public GitHub Issues; by September 2018, they had recorded 1,560 of them. Their head of talent at the time put it precisely: if you make a decision and it isn't written down, it didn't happen. Each of these companies had distributed teams, async coordination, and employees onboarded across geographies. Writing was the only medium that could carry the weight.

The verbal stance produced a different set of admired companies. Linear, Figma, and the YC startup template grew through founder-led conversation rather than process documentation. Paul Graham told founders to do things that don't scale. Loom turned into a verb. Tribal knowledge was a feature, not a debt. The cost of writing did not pay back when the team was small enough to fit in a shared Slack. Writing too much would have been overhead.

For seven years at Qonto, we went from pirate mode — small team, almost nothing written down — to a written culture where the beauty of a mind breathed through its verbs and its concision. I lived both sides of the pendulum there. Three years into building Well, I am writing more than I ever have. Not because I changed. Because the audience changed.

The error in the old era was never picking one stance. It was picking the wrong stance for your size. Small companies that wrote too much died of process before they reached product-market fit. Big companies that wrote too little died of context loss when their veterans left. The two stances coexisted because the audience was always human, and human teams come in different sizes.

The AI era collapses the choice.

It collapses it because the new audience is not a six-person team or a six-thousand-person company. The new audience is the population of agents you are about to spawn — and that population is unbounded, never sleeps, never sat in your Tuesday standup, and cannot ask a follow-up question across the desk. The agent reads what you wrote, or it guesses. The medium that wins is the one the agent can fetch.

Karpathy puts the inflection point precisely. As recently as November 2025, he was still writing eighty percent of his code by hand. By December the ratio had inverted. He stopped correcting the agent and started trusting it. Delegation became viable, and delegation has one structural requirement: the thing you delegate to has to be able to read what you mean.

The Incumbent Already Surrendered

The clearest signal that the old choice has collapsed is what the incumbents are doing.

On April 14, Notion's CEO Ivan Zhao announced that the company had rebuilt its MCP server from the ground up with Cursor and was inventing what he called Notion-flavored Markdown. The pitch combined the power of Notion blocks with the compactness of plain text. Translated into plain English: agents need markdown, our blocks are not markdown, here is a hybrid we hope will buy us time. Notion is not denying the new era. It is implementing it inside its own walls. Three weeks later, Notion AI Custom Agents went paid at ten dollars per thousand credits. The same feature meant to keep teams inside the walled garden became the budget line item teams started auditing.

Amazon's case is the most poetic. The company that invented writing-as-an-operating-system rolled out an internal AI tool called Cedric in September 2024. Cedric drafts six-page memos in seconds. An AWS executive, quoted in The Ken, described uploading a previous document into the tool, asking for a summary, and using that as scaffolding for the new memo. Two weeks of writing collapsed into a prompt. Andy Jassy reportedly tells some teams to start with a one-pager and only escalate after alignment.

If the six-pager was the operating system, Cedric is the just-in-time compiler. The substrate is still text. The author has changed.

What the Migration Actually Looks Like at Well

At Well, the migration I described in the opening is concrete, not aspirational. Our specs live in the repository. Our standards are markdown files alongside the code they govern. Our decision logs are pull requests with explanations in the description. Our agent contract, the file the agents themselves read before acting on our behalf, lives at the root of the project as CLAUDE.md. When an engineer or an agent needs to know why a piece of architecture exists, they fetch the answer from the same place they fetch the code. No SSO. No second tool. No context fragmentation.

But the migration itself is not the lesson. The lesson is underneath it.

When an agent fleet ships bad quality, the cause is one of three things: not enough context, too much context, or the wrong context. Each requires a different fix. Most teams notice the first. Almost no one notices the third.

I have a firm intuition that we should never use generic agents to perform high-level software engineering quality. If our agents need to be better than us, they have to be T-shaped specialists, deep in one domain, light in the rest. The shape was named by David Guest in The Independent in 1991 and popularized by IDEO's Tim Brown for designers in 2010. Nobody has applied it cleanly to agent fleets yet. They should. The job is to find the right domain scope and fill it in with context, best practices, standards, and working instructions: enough for the agent to perform, not enough for it to take shortcuts. The empirical case for the shortcut risk is sharper than I expected. Tang and colleagues showed in 2023 that LLMs are lazy learners that exploit shortcuts in prompts, and that larger models exploit them more, not less.

The context window is the agent's cognitive load, the same way it is for a person. Anthropic's engineering team named the dynamic plainly in September 2025: "like humans, who have limited working memory capacity, LLMs have an attention budget that they draw down as they take in additional context." John Sweller named the same constraint for human learners in 1988 and called it cognitive load. The two ideas are the same idea at different scales.

When I ran product at Qonto, my job was to load each PM optimally. Some could hold a five-piece product mix at full complexity and ship excellent work. Some could only hold one large piece at a time and would fill their cognitive load with that single thing. The moment you added a second, the first one degraded. The skill, as a head of product, was to know which kind of person you had and load them accordingly.

Agent fleets work the same way. The context window is not a capacity to fill, it is a cognitive budget to respect. When the window saturates, you do not need a bigger model. You need to split the domain. This is the same operation Matthew Skelton and Manuel Pais describe in Team Topologies: "explicitly thinking about cognitive load can be a powerful tool for deciding on team size, assigning responsibilities, and establishing boundaries with other teams." Domain boundaries are cognitive-load boundaries. The fleet boundaries follow the same law.

The compounding move sits one level above. If you want a kaizen company, the one Toyota built and the one that improves itself one defect at a time, you need a fleet that sees its own bad quality, runs root-cause analysis on it as System 2 work, not System 1, and writes the fix into a standard the right specialist agent will read next time. Not a fix for the bug in front of you. A fix that survives the bug. That is the only way the system gets better instead of just busier.

This is the same test we proposed in our SaaSpocalypse piece, applied to knowledge management. Look at where your specs live. If they live in Notion behind SSO, your AI is a layer on top, no matter what your landing page says. If they live as plain text in the repository, scoped to the right domain, written for the agent that owns it, the substrate is genuinely different.

The Real Question

The real question is no longer whether to write things down. Karpathy's framework settled that. Software 3.0 runs on context, and context that does not exist as written substrate cannot be loaded into the window where the program executes.

The real question is where you write things down so that every agent your team will ever spawn can read them.

If the answer is Notion, you have already lost a year of agent leverage to whoever picked the right substrate first. If the answer is "in the repo, in markdown, beside the code, version-controlled, and addressable," you have built the substrate the new reader was waiting for.

The companies that figure this out in 2026 will spend 2027 with a quietly compounding advantage. Their agents will know things their competitors' agents cannot find. Their onboarding will take days instead of weeks because the new hire reads the same files the agent reads. Their decisions will be reproducible because the context behind them is fetchable.

For the past thirty years, businesses competed on process, salespeople, and product. Last year I argued they would compete on the depth of their context graph. Today the question is more concrete: where does the graph live, and can the agent reach it?

At Well, the answer is in the repository, in markdown, beside the code our agents already read every day.

The audience has changed. The substrate is text. The author, increasingly, is going to be a machine. The only thing that has not changed is that the work belongs to the people who choose to write it down.

Maxime Champoux is the co-founder and CEO of Well.