Our brilliant amnesiacs
Taming new complexity to progress AI-assisted software creation
🔌 Join our waitlist at SpecStory.com. Be part of our early community shaping context aware AI-assisted software creation. First Cursor VSC extension launching very soon.
“Googlers have a high tolerance for complexity."
The words still linger from my first days at Google over a decade ago. In that orientation room we basked in the subtle praise of our collective intellect.
How naive we were.
How naive I was.
In retrospect — it wasn't praise — it was a warning.
Google's DNA is woven with complexity: labyrinthine technical systems, organizational structures, and products that layer. Much of this is irreducible and necessary. When serving billions the reality is simple rarely suffices.
But complexity comes with cost:
New employees and services struggle to integrate, drowning in endless documentation and dependencies.
Maintenance costs compound, often exponentially.
User experiences grow cluttered, despite our best intentions to shield them.
Decision-making tangles, caught in the web of conflicting priorities.
This challenge extends well beyond Google's walls: the core challenge of software development is to manage complexity.
For decades, we've built abstractions and scaffolding. They help humans cope with complex systems by reducing cognitive load. Yet even as we create tools to manage complexity, we seem destined to fill that newfound capacity with... more complexity.
AI coding assistants are now everywhere (GitHub Co-Pilot, Cursor, Codeium etc.). We’re discovering — I’m discovering — a new form of complexity to tame.
The Brilliant Amnesiac Problem
Imagine working with a brilliant programmer. They forget your project every few hours. They can write elegant code. They can solve complex problems. And, they can explain intricate concepts.
But, they can't remember yesterday's architectural decisions, your codebase's patterns, or last week's trade-offs.
This is no exaggeration—it’s the reality of AI coding assistants today.
Many LLM-powered tools are very capable within their context window. But, they are fundamentally amnesiac.
While some IDEs are trying to help solve for this, many interactions end up starting fresh, divorced from previous context.
It's a peculiar form of intelligence: vast but ephemeral, knowledgeable but stateless.
Current LLMs operate like RAM without persistent storage.
They can each hold an impressive amount of information in their respective context windows (e.g., 200K → 2M tokens), but once that window is exhausted, that context is gone.
This creates a fundamental mismatch with how software development actually works:
Humans build up mental models over time
Codebases evolve through accumulated decisions
Architectural patterns emerge through iteration
Team knowledge grows incrementally
Our current tools and abstractions don't bridge this gap. Traditionally, software engineering has given us powerful tools and processes for managing complexity:
Design patterns to codify common solutions
Architectural boundaries that separate concerns
Documentation like ADRs to captures decisions
Tests that verify behavior
These will continue to retain their value but they were designed for human-to-human knowledge transfer. They don't adequately serve the needs of human-AI collaboration. When an AI assistant RAGs over your codebase, it doesn't necessarily see the rich history and context that a human developer builds up over time. It sees only what fits in its current context window or can be vectorized and compressed without much guidance.
Towards more durable shared memory
What we need isn't just better documentation or more comments. We need new abstractions that enable persistent, queryable understanding. This includes:
Semantic knowledge repositories storing project-specific patterns, conventions, and terminology.
Intent records automatically capturing the why behind decisions—both architectural and logical.
Evolution Histories tracking why systems changed, not just how via AI human collaboration. Not just temporally but at different grains and altitudes.
Personal AI profiles capturing individual coding preferences, project-specific idioms, and the historical context of decisions.
Progressive context loading that summarizes system components hierarchically. Just-in-time retrieval of relevant context. Anchoring semantic links that survive refactoring.
The effectiveness of these new abstractions will depend on precision. Just as vague requirements lead to poor implementations, imprecise abstractions leads to confused AI-Human collaboration.
For example, consider two ways to document a decision:
Imprecise: "We chose PostgresSQL over MongoDB for better performance."
Precise: "We switched from PostgreSQL to MongoDB in March 2024 because our write-heavy workload (>10K writes/sec) was causing contention issues. Query latency dropped from 200ms to 15ms after migration."
That difference impacts both the ability of AI and humans working alongside to make informed future decisions based on rich context.
We were born to work together like feet, hands, and eyes, like the two rows of teeth, upper and lower. To obstruct each other is unnatural. — II. 2
What this means
We need to think beyond just the immediate interaction with AI assistants. We need to consider:
How to maintain consistent context across sessions
How to efficiently transfer project knowledge to both AI and humans
How to capture and query AI assisted development history
How to represent architectural decisions in more friendly machine-readable ways (e.g. LLM empathy)
How to build up persistent, project-specific AI understanding
The tools we build today will shape how we collaborate with AI tomorrow. Abstractions that:
Enable durable AI memory
Support precise knowledge transfer
Allow progressive context building
Maintain consistent understanding
Bridge the human-AI cognitive gap
At SpecStory, these challenges shape our vision. Our tools—designed first for software composers—help capture, search, and learn from every AI coding journey. We aim to build to enable more cognitively efficient AI development partners that unlock software creation widely.
Just as abstraction and design helped us tame code complexity, we must now conquer the challenges of AI collaboration.
The goal is to transcend the “brilliant amnesiac” problem, ensuring that each interaction builds on a durable, context-aware foundation.
This last mile is hard, but the rewards—persistent, contextually intelligent AI collaboration—will transform how, and who, can create software.
🔌 If you're wrestling with AI context and collaboration in your composer or AI-first builder workflow — and especially if you’re using Cursor right now — we’d love to hear from you.
Sign up for our waitlist at SpecStory.com, join our early Slack community, and stay tuned for our first extension release coming soon.