Chapter 1: AI Statelessness and Context Window

Therefore, the amount of documentation in the entire codebase must be kept minimal and clean, and kept in sync as much as possible. Otherwise, you're just reducing AI's capabilities.

3. Context Window: The Most Important Resource for Programmers in the New Era

"The upper bound of AI's context window will be the most important 'resource' for programmers in this new era."

Extended reading: How token count quantifies project scale and impacts context selection strategies, see Token as a Quantitative Measure of Project Scale. For practical tool selection based on context window constraints, see Tools and Context Selection: Why AI IDEs Sell "Context Selection Capability".

In the past, people cared about CPU, memory, and hard drives, but as time goes on, these things are getting cheaper. What's most expensive now? Tokens.

AI's performance changes based on how much context window you occupy. When you find AI's capabilities improving, you'll definitely push against its upper limit, and you'll definitely become more wasteful. Even if the model itself becomes cheaper, because your usage increases dramatically, the money you spend may still be increasing.

The principle of large model sessions is roughly this:
You originally had four messages in this session, and you want to send a fifth message. It's not actually continuing on the original session, but creating a new message whose context is the previous four messages. This means that even though it looks like the same session, there's actually no relationship between each message.

This leads to the problem of token cost management:

• If you only have two messages in a session, the tokens you consume are only the cost of two messages
• If the session already has ten messages, and you send the 11th and 12th messages, your cost isn't just two messages, but scales like 1 + 2 + … + 11

Therefore, the longer you use it, the more you use, and the more expensive it becomes.
Vendors will have a workflow behind the scenes that automatically compresses previous messages, most likely using large models: the large model reads 10,000 words of the conversation, then outputs a 1,000-word summary. As soon as messages are compressed, some information is inevitably lost, and this information might be the most critical. At the same time, large model performance itself declines as the occupied context space increases. Each large model has its own different sweet spot at different context lengths. Therefore, the longer a session, the dumber the AI becomes.

Empirically, when a session's context left is only 40%, it will already start to "become dumb." At this point, try to restart.

4. Session Relay Strategy in a Stateless World

For requirements of medium complexity and above, a relatively healthy workflow is:

1. In the first AI session, have it read as many global documents and related code as possible. After it has enough understanding of the problem background, have it write an execution plan
2. Carefully review this plan, clarify every point you find unreasonable or questionable with AI, then have it solidify this document
3. Start a second AI session, have this new AI read the document, then follow the document step by step
4. When you find it becoming "dumb" at some step, restart a new AI and have it continue from where it was interrupted (of course, it needs to understand what we've already done first)

After the entire plan is complete, including tests, lint, and quality checks passing, delete this plan.
Because this plan contains a lot of procedural information. If a future AI session reads these procedural pieces of information, it will be misled.

A correctly maintained codebase should not contain any procedural information—only result information.
It won't say "I changed A to B," otherwise it would require new readers to understand why it was A in the past and why it's B today, creating confusion in their minds.

You should delete all information related to A and only keep B.
This way, any new reader—including every new AI session—doesn't need to try to understand "what once existed."

The complete form of this relay strategy in actual workflows, see AI-Native Workflows: Plan–Act, Test–Code, Doc–Code–Doc.

5. Full/Snapshot Documentation vs. Incremental Documentation

Documentation is essentially helping large models cache memory.
Full, snapshot-style documentation is superior to incremental documentation.

AI's capability upper bound is the upper bound of its context window. Humans are the same—human context windows also have upper bounds.
How do humans handle complex systems? Think about how large companies collaborate:

• Different functions and teams collaborate through clear boundaries and interfaces
• Each team has a complete "snapshot understanding" of its own context, rather than relying on a long development history

Our collaboration with AI is actually simulating this collaboration between different functions and teams in large companies.

How documentation and code stay in sync in this mode, and how documentation participates in workflows, see AI-Native Workflows: Plan–Act, Test–Code, Doc–Code–Doc.