The biggest lie in AI-assisted development

The biggest lie in AI-assisted development: “Just generate better specs and your problems will go away.”

Wrong problem. The real enemy isn’t insufficient planning. It’s context decay.

Here’s what actually kills AI-assisted projects: your mileage may vary but around 50-100 prompts, depending on how many tokens you’ve burnt, the AI “forgets” your architecture. It suggests things that break existing patterns. It asks about components it built fifty prompts ago. You spend more time re-explaining than building.

This is context decay.
Throwing more specs at it makes it worse, not better.

I’m proposing a different solution, and what I’ve come to call Simulated Recall via Shallow Indexing. Instead of expanding documentation, you compress architectural memory.

You maintain a shallow index of about two to three thousand tokens - component locations, key decisions, design rationale, interconnection patterns. Before every task, the AI consults this index first. It reconstructs relevant context on demand. After every feature, the AI updates the index. The system maintains living memory of itself.

This isn’t RAG or vector search. It’s simpler. It’s a map the AI maintains of its own work. Best part? Large context windows become a nice-to-have, but not essential.

The traditional approach relies on long conversation history - eventually that gets truncated, AI loses critical context, and now you’re re-explaining the same decisions repeatedly.

The SR-SI approach keeps a compact index that never gets truncated. The AI self-orients before each task. Zero re-explanation overhead.

Real results from my experiments: one project without SR-SI consumed 2.56 tokens per line of code for context maintenance, with drift at ~200 prompts. The biggest factor was my ability to target my prompts.

With SR-SI: I’ve dropped down to 0.37 tokens per line - an 85% reduction. Coherent collaboration past a thousand prompts with zero context loss.

The compound effect is real.

• Early project, savings are modest.
• Mid-project, you’re 3-4x faster.
• Late project, AI understands your codebase better than a new team member would.

This works because the index acts as prosthetic memory.

The AI doesn’t need to remember everything, it needs to know where to look. This mirrors human recall. We store cues that help us reconstruct. The cue triggers the relevant mental model.

When I return to a building design after weeks away, I don’t re-read every document. I look at the structural diagram. That reminds me of the load paths, the material constraints, why we chose that form. The diagram is a shallow index of deep knowledge.

What you get isn’t just efficiency. It’s structural continuity. The AI maintains awareness of how components interrelate, why decisions were made, what constraints are load-bearing.

This is the difference between “here’s code that works” and “here’s code that fits your system.”