TL;DR
The Elephant-Goldfish Model (EGM) separates the agent that drafts a spec from the agents that review it. The drafter (Elephant) carries the whole conversation; each reviewer (Goldfish) is a fresh subagent that sees only the spec and the files it links. Anything the spec relies on but never says is invisible to a Goldfish, so it gets flagged. Google open-sourced it as a plugin for Claude Code, Codex and Antigravity (Apache 2.0, "not an officially supported Google product").
The core idea is sound and cheap to adopt: it is self-containment testing for design docs, plus context isolation as a defense against confirmation bias. The plugin is heavier than the idea. It is a nine-persona, five-stage pipeline with strict prompt-level rules, and several of its guarantees (phase write boundaries, reviewer isolation from AGENTS.md / GEMINI.md) are conventions or partly verified, not enforced.
Sources
LinkedIn post, Shubham Saboo (Senior AI PM at Google), 2026-11-08, plus its comments.
google/elephant-goldfish-model: README,
docs/designs/architecture.md,docs/harnesses.md,TESTING.md, and theegm-review,egm-brainstorm,egm-resolve,egm-drift-reportskills. Site: egm.dev.Dave Rensin, "Elephants, Goldfish and the New Golden Age of Software Engineering" (Medium, 2026-04-27; updated 2026-10-21 when the plugin was open-sourced).
The idea, from Rensin's essay
Rensin's claim is "design is the new code": when an AI writes the code, the micro-decisions a human used to leave in the logic must move left into the design doc, or nobody responsible for the system will understand it. He reports the method grew out of an internal tool that reached more than 100,000 Googlers within months, with dozens of contributors.
Three observations drive it:
Re-bootstrap from a doc. After a crashed session, a written statement of intent and progress restores context in seconds; re-feeding code does not.
Models sprint off cliffs. Given context but no guardrails, the agent invents APIs and architecture. The doc's file-by-file plan is the guardrail.
sizeof(docs) << sizeof(code). Docs are a cheaper, more reliable context source than source code.
The workflow:
Grow the Elephant (no code). Load context, have the model summarize it back, then hold a 20–30 minute design argument under a "no code" rule. Push back on sycophancy ("you are not being helpful"; "why do you think that?"). Have the model propose the first design itself, because that tests whether it understood. Debates can run hours or days.
Teach the Elephant. Write the doc section by section: Problem, Technical Plan, Alternatives (rejected ideas as guardrails against later hallucination), Detailed Implementation listing every file to create or change and why.
Goldfish protocol. Fresh sessions run a comprehension test ("explain what this does and how my system works"), a critic review (he finds about 30% of suggestions valuable, an anecdote), and an implementation-readiness test. Loop until findings are nitpicks, then human review.
Implement with guardrails, then a deliberately harsh AI code review.
For legacy code he proposes "peanuts and hay": generate README.md files bottom-up from leaf directories, with a human fixing each leaf (he says the AI is about 50% wrong there), then roll summaries upward to the root. He says this takes about a week regardless of codebase size. READMEs can retire once design docs cover every file. The essay closes with the claim that engineers are becoming managers of agents.
How the plugin implements it
The plugin turns the essay into seven skills, nine stateless reviewer personas (agents/) and versioned rubrics (resources/document_standards/). Install is one command per harness; Claude Code uses claude plugin marketplace add google/elephant-goldfish-model then claude plugin install egm@egm.
Skills. egm-brainstorm interviews you, then sends the idea to a seven-lens Goldfish swarm (Contrarian/YAGNI, cost and token economics, developer ergonomics, migration and backward compatibility, observability/SRE, long-term tech debt, and an "Inventive Catalyst" that hunts for the trade-off being accepted as inevitable) and writes concepts_brief.md. egm-draft writes design_draft.md section by section with a checkpoint after each. egm-review runs the pipeline below. egm-resolve brings findings back into the Elephant's context, classifies each as PROPOSE FIX or CONTEST, and applies approved edits. egm-review-loop runs any reviewer set against any document. egm-bootstrap is the peanuts-and-hay README generator. egm-drift-report compares checked-in docs to current code and reports only differences (missing features, missing fields, hardcoded shortcuts, architectural divergence).
Semantic split. The reviewer finds a ## Detailed Implementation Plan heading (or a synonym) and splits the doc into a FeatureRange above it and a DetailedRange below. Design critics see only the architecture; readiness reviewers see only the plan.
The five-stage review (numbered 5–9 in the skill):
| Stage | Reviewers (fresh subagents) | Reads | Rubric | Report |
|---|---|---|---|---|
| 5 Zoom out | zoom-out, inventive-catalyst | whole doc + linked files | zoom-out standard (simplicity, YAGNI, reuse) | zoom_out_report.md |
| 6 Comprehension | comprehension (spawned directly, no synthesizer) | the doc alone | none: paraphrase test for self-containment | comprehension_report.md |
| 7 Critic | design, structural, style | FeatureRange + linked files | feature-spec standard (scale, failure modes) | critic_report.md |
| 8 Zoom out again | zoom-out | whole doc | zoom-out standard, aimed at what stages 6–7 added | intermediate_zoom_out_report.md |
| 9 Implementation readiness | implementation-readiness, codebase-details, style | DetailedRange + linked files | implementation-readiness standard (paths, signatures, tests) | implementation_readiness_report.md |
A synthesizer persona fans reviewers out in parallel, dedupes and writes the report; where a harness cannot nest subagents, the orchestrator dispatches reviewers directly. Presets run all stages interactively, all at once into a consolidated_review_report.md with Blocker / Major / Nit priorities and a traceability matrix, feature-spec only (5–8), or readiness only (9). Each stage allows at most one re-audit, after which remaining findings are recorded as accepted trade-offs.
Design choices worth noting.
Fail closed on isolation. With no subagent tool the review stops: "a review in the same context is not a Goldfish review." Commenters singled this out as the part to trust.
Stage 8 exists to catch review-induced bloat. Reviewers ask for more; a second zoom-out checks that fixes did not add complexity.
Linked files become Goldfish context. Relative links inside the working directory are added automatically; URLs and out-of-tree links need approval and are saved locally so reviewers that cannot fetch still see them.
Artifact-first UX. Drafts and reports go to files, never long chat dumps, to keep the Elephant's own context clean.
Anti-sycophancy as prompt law. Banned adjectives and apologies, critique first, one question per gate.
Phase write boundary. Brainstorm through resolve should touch only spec and review files; once stage 9 passes, the plan's file list is what implementation may write.
Tradeoffs and failure modes
The weakest point is that "zero-context" removes the conversation but not the model. A Goldfish running the same model as the Elephant shares its priors, so the errors it misses are correlated with the drafter's. Context isolation fixes conversational confirmation bias; it does not add an independent perspective.
Isolation is only partly verified.
docs/harnesses.mdsays Claude reviewers setomitClaudeMd: true, but issue #237 reports Codex CLI and Antigravity supplying projectAGENTS.md/GEMINI.mdto reviewers. The tests check parent-turn isolation only. A Goldfish that reads your house rules is not reviewing what the doc alone says.Linked files are context too. Reviewers see the doc plus everything it links. Stale linked docs pass staleness straight into review, and anything unlinked is invisible. The doc's review quality is bounded by its link hygiene.
Signal-to-noise is low by design. Rensin's own figure is about 30% of critic suggestions worth acting on. Rubric reviewers are asked to find problems, so they always do; the human triage load scales with stages × reviewers. The one-re-audit cap and stage 8 are the plugin's brakes on this.
Cost. A full review is five stages, up to three reviewers each, plus a synthesizer and possible re-audits, each re-reading the doc and links in a cold context with no shared cache. The Muse fixture used 15 fresh-context reviewers for one uninterrupted review. Worth it for a load-bearing design, overkill for a small change.
Guarantees that are conventions. Phase write boundaries are "a convention, and nothing enforces it." A PreToolUse hook restricting writes to spec paths would make it real. The drift report is an LLM comparison that prints only differences, so a missed divergence is silent.
Spec-first front-loads cost. Design debates of hours or days pay off when the design is the hard part; for exploratory work a spike may teach more per hour. The method assumes requirements can be argued out before code.
The post overstates two things. "Every AI design review today has the same flaw" is true of single-session self-review, not of review in general; a commenter noted that human code review already happens in a different person's context. And "thousands of Google engineers use this plugin" is not what the essay says: Rensin's 100,000-Googler figure is for the tool his team built using the method, and the plugin is described as one "my team and I" use. The repo says it is not an officially supported Google product.
Evidence is anecdotal. No eval compares EGM review against single-session review or a different-model reviewer. The repo's tests check manifests, links and workflow fixtures, not review quality.
Review checklist
Use this when adopting EGM, or when judging any "fresh reviewer" design-review setup.
Do reviewers truly start cold? Check what host instruction files (CLAUDE.md, AGENTS.md, GEMINI.md) reach the subagent, not only the conversation.
Does at least one reviewer run on a different model family from the drafter, to break correlated blind spots?
Does the review fail closed when fresh subagents are unavailable, rather than reviewing in-context?
Does the comprehension test read the doc with no linked files, and does the doc pass it?
Are the doc's links current? Stale linked docs feed stale context to every reviewer.
Does the doc have an Alternatives section recording rejected options, so later agents do not reopen them?
Does the implementation plan list every file to create or change, and is that list used as the write boundary?
Is the write boundary enforced by a hook, not just a prompt?
Is there a cap on review rounds, and a check that fixes did not add complexity (EGM's stage 8)?
Is triage cost tracked: findings raised vs accepted per stage? Drop stages that rarely produce accepted findings.
Is drift checked on a schedule, and is "no drift reported" treated as weak evidence?
Is the review proportional to the change? Full five-stage review for load-bearing designs; a single critic pass for small ones.
Related entries
Filed as R017 under 3.3 Agent delivery workflows, also 4.1, 6.1 and 7.2.
R016 (human verification): EGM's critic reviewers are the line-by-line checker R016 calls weak; its human triage of routed findings is closer to R016's auditor role. Neither EGM nor Rensin measures reviewer accuracy with planted errors.
R006 (harness terms): a concrete use of subagents and context management, and of failing closed when a capability is missing.
R010 (PageIndex): bootstrap's bottom-up README tree is the same idea as PageIndex's section tree: a map the agent reads before the full text.