The Elephant-Goldfish Model: Why Google’s AI Engineering Method Matters for Startups

What if the way most engineers use AI is fundamentally wrong?

Not wrong in the sense of “they’re using the wrong tool.” Wrong in the sense of “they’re using a powerful tool like a toy and getting toy results.”

Dave Rensin, an engineering leader at Google, recently published a paper detailing how his teams built an internal tool used by 100,000+ Googlers. The tool was successful not just because they used AI, but because of how they used it. He calls it the Elephant-Goldfish Model.

I’ve spent the last few weeks adapting this methodology for Series B startups. Here’s what I learned.

The Problem: Design Judgments Are Vanishing

Historically, design judgments, the “why” and “how” of a system, sat in two places:

Design documents (explicit)
The code itself (implicit micro-decisions left in the logic)

When humans write code, they leave a trail of micro-decisions behind. But when AI writes the code, the human is no longer making those micro-decisions.

The danger: If we don’t force all design judgments into the design document before code is written, the resulting system becomes completely incomprehensible to the human responsible for it.

Rensin’s prediction: “Whether in a blizzard [of AI-generated code] or a binary, the code is going to become opaque to us. When the code becomes opaque, the only artifact that matters is the design.”

Design is the new code.

The Elephant-Goldfish Model

The model is based on a simple metaphor:

The Elephant 🐘

“An elephant never forgets.”

This is the heavily-prompted, context-rich AI session, and the resulting Design Document it helps you write. The Elephant holds all the institutional knowledge, the micro-decisions, the arguments you had with the model, and the entire history of the feature.

The Goldfish 🐠

A brand new, completely fresh AI session with zero memory.

It only knows exactly what is put right in front of it.

The Mantra

“Feed the Elephant; test it against the Goldfish.”

The Four Phases

Phase 1: Growing the Elephant (NO CODE YET)

This is the hardest part for most engineers to accept: You are not allowed to write code yet.

Step 1: Context Loading Point the AI at existing design docs or source tree. Ask it to give you a high-level description. If it misunderstands your system on minute one, it’ll write terrible code on minute ten. Correct immediately.

Step 2: The “No Code” Rule

"I do not want you to create code. We are not going to create code. 
Resist your impulse to create code. Instead, we are going to have 
a design discussion. I am about to describe a feature. I want you 
to ask me clarifying questions and challenge my assumptions."

Have a back-and-forth conversation for 20-30 minutes. Really argue with the AI. These models are excellent interrogators. Make it push your thinking.

Step 3: The Sycophant Challenge AI models are trained to be helpful, which often makes them “insufferable sycophants.” If the AI stops asking hard questions and just says “Great idea!”, force it back:

"When you agree with me you are not being helpful. Your highest and 
best use is to challenge my thinking."

Step 4: The First Draft Technical Proposal Ask the AI to propose an implementation in prose and block diagrams. Not code.

"Based on your understanding of the codebase and what we discussed, 
I would like you to give me a first draft proposal of a technical 
implementation. I'm not looking for code. I want prose from you 
that demonstrates your understanding of my system."

Argue with the AI until you settle on a solid approach. This might take hours or days for complex decisions. Do not rush this.

Phase 2: Teaching the Elephant (The Design Doc)

Now create the Markdown document that serves as the absolute source of truth. Build it iteratively in the same Elephant session.

The structure:

The Problem: Plain English business problem (3-5 sentences)
The Technical Plan: Jargon-light component description + block diagrams
Alternatives Considered: Ideas you considered but rejected (critical guardrails against future hallucinations)
Detailed Implementation: Step-by-step plan. Enumerate every single file that will be created or changed, and the rationale for why.

Save this file. This is your new source code.

Phase 3: The Goldfish Protocol (Validation)

How do you know if your design doc is actually good, or if it’s relying on context from your Elephant session?

You test it against a Goldfish.

Test 1: The Comprehension Test (Fresh Session)

"Read this document and the files it references. Tell me what it's 
trying to accomplish, and how my system currently works as it 
relates to this feature."

If the Goldfish cannot explain your system based only on that document, your doc is missing context. Add the details and repeat. Do not skip this.

Test 2: The Critic Review (Fresh Session)

"Assume the role of an expert technical reviewer. Read this design 
doc and tell me all the things I missed, all the faulty assumptions, 
all the edge cases I'm missing."

Rensin finds ~30% of suggestions are highly valuable. Iterate until recommendations become “nit picks.”

Test 3: Implementation Readiness (Fresh Session)

"Does this document absolutely have all the information you would 
require to successfully implement this feature in your first pass?"

If it asks questions, answer them in the doc. Repeat until satisfied. Then human review.

Phase 4: Implementation (FINALLY)

Step 4: Coding with Guardrails

Only now do you write code:

"Read this design doc and the files it references. Implement the 
feature as described. Follow the plan exactly."

Because the doc explicitly lists every file and every change, the AI produces much higher quality code.

Crash recovery: If the AI session crashes, open a new session, hand it the design doc, tell it to read the doc and all files referenced. You’re immediately back in business. This is why the Elephant-Goldfish model is resilient.

Step 5: The “Mean” Code Review

When the code is done, feed it back to the AI:

"I have a strong intuition that this code is of poor quality. Please 
tear it to shreds and tell me all the ways it sucks."

Yes, that’s the actual prompt. Iterate until critiques are trivial.

Why This Matters for Startups

The Google teams using this method have:

Time for 2-3 day design debates
Dedicated platform engineering support
NotebookLM and advanced tooling
Management structures that support rigor

Startups don’t have these luxuries. But they also can’t afford to skip design discipline, especially with AI generating code faster than humans can review it.

The adaptation: Compress the timeframe without compressing the rigor.

Phase	Google Pace	Startup Pace
Growing the Elephant	2-3 days	2-4 hours
Design Doc Iteration	Hours	30-60 min
Goldfish Tests	Multiple sessions	One focused session

The key is maintaining the principles (no code before design, Goldfish validation) while adapting the duration to startup velocity.

The “Peanuts and Hay” Method for Legacy Code

What if you’re not starting fresh? Rensin has an answer: recursive README generation.

The process (~1 week, any codebase size):

Leaves (Peanuts): AI reads leaf directory files → generates README.md → Human verifies (~5-10 min, AI ~50% wrong here)
Branches (Hay): AI reads subdirectory READMEs + local code → generates parent README.md
Root: Repeat upward

Result: Feed the Elephant just the README hierarchy. It understands the codebase instantly with minimal context window.

When to delete READMEs: When all code files are referenced in design docs.

Integration with Institutional AI

The Elephant-Goldfish Model is tactical. It tells you how to use AI for design and implementation.

Synthetic Scale is strategic. It addresses what happens when you have:

N humans + M agents
Coordination chaos (O((N+M)²) complexity)
Signal vs. noise problems
Bureaucratic resistance (Moral Mazes)

The integration:

EGM gives you design-first development and validation
Synthetic Scale gives you coordination infrastructure for multi-agent teams
Together, they make institutional AI possible

Call to Action

If you’re a Series B founder dealing with:

PRs sitting open for days despite 10x code generation
Multiple teams building overlapping features with AI
Loss of context about what’s AI-generated vs. human-written

The Elephant-Goldfish Model is the tactical fix. Combined with Signal Architecture for coordination, it’s how you make 10x speed actually translate to 10x value.

The 14-day AI Infrastructure Audit:

Week 1: “Peanuts and Hay” bootstrapping + Elephant sessions for top 3 workflows
Week 2: Goldfish Protocol validation + LLM-as-Judge implementation

Before you spend $500K on enterprise AI software, you need the foundation.

References

Rensin, Dave (2026). “Elephants, Goldfish and the New Golden Age of Software Engineering.” Medium
Sivulka, George (2026). “Institutional AI vs Individual AI.” a16z news.
David, Paul A. (1990). “The Dynamo and the Computer: An Historical Perspective on the Modern Productivity Paradox.”
Perez, Carlota (2002). Technological Revolutions and Financial Capital.