Skip to main content
Logo image
Apptastic Coder
AI & Development

Elephant-Goldfish Model: Why Coding Agents Need Independent Design Review

Keep the project context for designing, then give reviewers a fresh start

By Team Apptastic7 mins read

Full Article

Read the complete article, including examples, background, practical insights, and technical details.

Abstract orbital cover for Elephant-Goldfish Model and independent AI design review

A coding agent can produce a convincing architecture, explain every decision, and then congratulate itself for choosing the right approach. That sequence feels productive. It also creates a dangerous possibility: the review may inherit the same assumptions that shaped the design.

The problem is familiar to human engineers. After discussing a feature for hours, everyone starts treating unwritten decisions as obvious. A new colleague reads the proposal and asks a basic question nobody documented. Suddenly, the design looks less complete.

Google's Elephant-Goldfish Model brings that fresh perspective into an AI workflow. Its central idea is simple: preserve context while designing, then remove conversational history when reviewing. For developers adopting coding agents, that separation deserves more attention than another promise of faster code generation.

What the elephant and goldfish actually do

The elephant keeps project context, requirements, and earlier decisions while helping draft a specification. Goldfish reviewers inspect the document and referenced source material without the preceding conversation. They look for assumptions, ambiguity, and implementation risks. You resolve trade-offs and approve the design before asking for implementation.

The project documents support for Claude Code, Codex, Antigravity, and ChatGPT desktop. It also provides a drift-reporting workflow that compares design documents with code. These capabilities are described in the official repository and setup instructions; check those instructions for your particular environment.

Despite its name, this is a plugin and workflow, rather than a new foundation model. The interesting architectural choice is how it distributes information between roles. One role benefits from remembering. Another benefits from arriving without the conversation that made a questionable decision feel settled.

Why self-review can miss the real problem

Imagine asking an agent to design a notification service. During discussion, you mention that email is the first delivery channel. Later, the agent proposes a database structure that assumes every notification has an email address. The implementation plan is internally consistent, and a review within the same conversation approves it.

But was email a permanent product constraint or merely the first milestone? If that distinction never entered the specification, the design may quietly make future channels expensive.

This is an illustrative scenario, not a reported result from the plugin. It shows why the reviewer needs to evaluate the written contract rather than mentally complete it using previous discussion. A design should explain its own boundaries. Otherwise, the team is approving a document whose most important requirements live somewhere else.

Self-review remains useful for obvious mistakes. It should not be the only checkpoint for decisions that shape persistent data, permissions, interfaces, or operational recovery.

Fresh context tests whether the specification stands alone

A reviewer without chat history creates a practical test: can another engineer understand what the system must do from the document and its supporting evidence?

That does not mean withholding relevant information. Reviewers still need access to referenced code, constraints, and requirements. The distinction is between evidence deliberately included in the design and assumptions inherited accidentally from a long conversation.

Consider an endpoint described as idempotent. A useful reviewer asks what identifies a duplicate request, how long that identity remains valid, and what happens when processing succeeds but the response never reaches the caller. Those questions transform an attractive adjective into implementable behavior.

The same method applies to phrases such as secure, scalable, backward compatible, and production ready. Ask what observable behavior would prove the claim. If the answer exists only in the author's memory, the specification needs another pass.

A practical example: reviewing a webhook design

Suppose your application needs outbound webhooks. Before implementation, write a short specification covering event creation, delivery attempts, authentication, retries, and customer visibility. Include links to the current event model and relevant background workers.

A reviewer focused on correctness might ask whether one event can be delivered twice. Another might question how secrets are rotated. An operational review could examine what happens when a destination stays unavailable for several days.

The resulting decisions might include stable event identifiers, bounded retries, an explicit signing scheme, and a way for customers to inspect delivery failures. None of these choices is universally correct; each depends on the product's requirements.

Your job is to decide which guarantees customers need and which costs the team can support. Record those decisions in the specification before generating code. This makes disagreement useful while changes remain relatively cheap.

Human approval must resolve actual trade-offs

An approval gate becomes meaningless when it asks only whether a document looks good. A useful gate presents decisions with consequences: what the system guarantees, what it intentionally excludes, and what operational burden the team accepts.

For the webhook example, unlimited retries might sound reliable but create an ever-growing backlog. A short retry window controls resource use but requires a clear customer recovery path. The agent can explain both options; product and engineering owners must choose the commitment they can maintain.

Keep a compact decision record alongside the design. State the choice, its reason, and the condition that would justify revisiting it. This helps future contributors distinguish an accidental limitation from a deliberate compromise.

Make explicit, testable acceptance criteria readable by someone who did not attend the planning discussion. Instead of saying that failures are handled gracefully, describe what the customer sees, which information operators receive, and how recovery happens. These details give reviewers something concrete to challenge and implementers something concrete to verify.

Also identify unresolved questions explicitly. If a dependency's behavior remains uncertain, assign an investigation before committing to an architecture that depends on it. An honest open question is more useful than a polished paragraph that hides uncertainty. Approval should mean the remaining risks are understood, with responsibility for follow-up clearly assigned to someone on the team.

Independent review is most valuable when it improves those decisions, rather than producing an impressive list of objections nobody prioritizes.

Design drift turns yesterday's truth into today's trap

An approved specification does not remain accurate automatically. Engineers change behavior during implementation, dependencies evolve, and urgent fixes introduce exceptions. Eventually, a new agent may read an old document and confidently build on a guarantee the code no longer provides.

Drift detection gives teams a reason to compare documentation with implementation regularly. Treat each discrepancy as a question requiring evidence. Perhaps the document is outdated. Perhaps the implementation accidentally dropped a requirement. Automatically changing either side can preserve the wrong behavior.

A useful workflow attaches the discrepancy to the relevant code path and expected behavior, then assigns someone to decide the correction. When the decision changes a public contract, update tests and documentation together.

For small teams, this can start with one consequential document rather than an attempt to synchronize every Markdown file in the repository.

Separate reviewers still need independent evidence

Fresh sessions reduce shared conversational assumptions, but they do not guarantee independent reasoning. Reviewers using similar models may share blind spots. Multiple agents agreeing on a design is therefore a signal to investigate, not proof that the design is correct.

Ask reviewers for specific findings: the missing requirement, the affected scenario, the supporting source, and the consequence. Reject vague demands to add complexity without explaining which failure they prevent.

Bring executable evidence into the process where possible. A small experiment can settle uncertainty about an API. A migration rehearsal can expose a compatibility problem. A focused test can demonstrate the behavior a specification promises.

Keep access boundaries intact throughout review. Reading a design does not authorize production changes. Our AI guardrails guide explains why application permissions must remain enforceable outside model instructions.

Start small and measure avoided rework

Choose a feature with meaningful decisions but a manageable scope. Use the elephant role to capture requirements and draft the specification. Give fresh reviewers the document and necessary references. Resolve actionable findings, approve the revised design, and then implement it.

Measure whether this process catches expensive misunderstandings before coding. Track which findings changed a requirement, prevented a migration problem, or clarified acceptance criteria. Also record review time and unnecessary objections. More review output does not automatically mean better engineering.

Skip elaborate ceremony for trivial edits. Apply the strongest scrutiny where a mistaken assumption would be difficult to reverse.

The lasting lesson of Elephant-Goldfish is that context has two jobs: helping an author understand the project and helping a reviewer verify the proposal. Those jobs benefit from different information boundaries. Let your coding agent design with memory, review with fresh eyes, and implement only after the important decisions are explicit.

Nov 21, 2026

Comments load as you scroll…