Google's New Plugin Makes Your Coding Agent Write the Spec First

Nothing here is sponsored — no affiliate links on this page. This breaking article is not the daily buyer-intent post. Facts below come from the sources listed at the end, checked 8 November 2026. We have not tested EGM hands-on, and nothing here is a hands-on finding.

Google open-sourced something today that isn't a model, isn't a benchmark, and isn't another agent framework. It's a plugin that forces your coding agent to do the one thing it always skips: write the spec before it writes the code.

It's called the Elephant-Goldfish Model, EGM for short. The Elephant is a long session that holds all the context and drafts the design. The Goldfish are fresh subagents with zero context who tear that design apart before a single line of code exists. Google says thousands of its engineers already use it every day to ship production code.

I have not run EGM hands-on, and I'm not going to pretend otherwise. Everything below comes from Google's Open Source blog post and the plugin's own repo and test records, checked 8 November 2026. Where a claim is Google's, I'll say so — because a launch-day announcement is a promise, not a review.

What EGM actually is

First, the correction that matters most: EGM is not a model. There are no weights to download and no API to call. It's an Apache 2.0 plugin made of skills, reviewer personas, and document standards that sit on top of whatever coding agent you already use. Your agent supplies the LLM; EGM supplies the discipline.

The idea comes from Dave Rensin's essay on elephants and goldfish, which Google's blog post quotes directly: "Design is the new code." The framing is blunt. AI made us faster at writing code, and that speed quietly scaled up the slop — wrong assumptions baked into pull requests, sessions that collapse under their own context halfway through a feature. EGM's answer is to shift the review left: catch the wrong assumption in a Markdown file, where it's cheap, instead of in a pull request, where it isn't.

One honest footnote from the repo itself: the README states EGM is not an officially supported Google product. It's an internal tool that escaped into the open. That doesn't make it less interesting — some of the best developer tooling starts exactly that way — but it does mean you shouldn't expect a support queue.

The loop: brainstorm, draft, review

The workflow runs through three commands, and the "no code" rule is the whole point.

/egm-brainstorm — grow the Elephant. You load the system context and co-design the feature with the long session: debate trade-offs, challenge assumptions, write no code. A six-lens Goldfish swarm then pokes at the idea from six directions — YAGNI, token cost, UX, migration, observability, and tech debt. The output is a concepts_brief.md.

/egm-draft — draft with the Elephant. The brief becomes a design document under docs/designs/, written section by section: problem definition, technical plan, alternatives considered, and an implementation plan that names the specific files to change.

/egm-review — the Goldfish Protocol. This is the part that makes EGM different from every other spec-first tool I've looked at. Five sequential stages, each run by fresh subagents who have never seen your conversation:

1. Initial Zoom Out — the whole document, checked at a high level.
2. Comprehension Test — a Goldfish paraphrases the design back. If the paraphrase is wrong, the doc is ambiguous. That's the test.
3. Critic Review — design, structural, and style reviewers hunt for gaps and edge cases.
4. Intermediate Zoom Out — architecture rechecked after the fixes.
5. Implementation Readiness — file paths, data structures, and function signatures verified, go or no-go.

Each stage allows at most one re-audit. Findings get ranked Blocker, Major, or Nit. And there's a hard rule worth respecting: if your host can't spawn fresh subagents, EGM stops. A same-context review is not a Goldfish review — the whole mechanism depends on the reviewer sharing none of the designer's blind spots.

Later, /egm-drift-report compares the code you actually shipped against the spec. The docs recommend running it weekly, which is the kind of advice that sounds boring until the first time your implementation quietly wanders off from the design.

Where it runs — and what the test record actually says

EGM runs on any harness that can spawn fresh subagents. The repo's harness guide covers Antigravity, Claude Code (version 2.1.271 or later), Claude Cowork, Codex, ChatGPT, omp, and Muse. Claude Code reviewers get only Read, Grep, and Glob tools, and CLAUDE.md files are excluded from their context — the isolation is deliberate.

Google published real test runs, not just a compatibility list, and the record is refreshingly mixed:

• Antigravity CLI 1.4.5: 16 native reviewers ran, stages in order. Clean pass.
• Codex 0.163.0: 15 native reviewers completed in order, two live tests in 573.13 seconds — roughly ten minutes for a full review cycle.
• Codex CLI with the v0.1.0 ZIP: full suite passed in 482.30 seconds.
• Claude Cowork: the run stopped after stages 5 to 7 on a usage limit. Not a failure of the method, but a reminder that five stages of fresh-context reviewers burn real quota.
• Issue #237: AGENTS.md leaking into Codex reviewers — the isolation isn't airtight on every host yet.

No accuracy benchmark has been published. The evidence so far is adoption plus end-to-end harness runs, and Google is honest about that shape of evidence even if it doesn't say so in those words. Ten minutes and a pile of tokens per review cycle is the price of the thing. Whether that price is worth it depends on how expensive your last wrong-assumption pull request was.

EGM vs Spec Kit, Kiro, and Superpowers

Spec-first tooling is suddenly a crowded room, so here's the honest map:

EGM's distinct move is the one in the third row: the review happens on the spec, by agents who know nothing, before code exists. Spec Kit and Kiro center on human review between phases. Superpowers isolates subagents mainly at implementation time. If your pain is "the agent built the wrong thing confidently," EGM is the only one of the four that attacks that exact moment.

The catch, stated plainly

• No hands-on testing yet — mine or anyone independent's. This article is built from Google's blog post, the repo, and its test records. The "thousands of Googlers" line is Google's claim, and there is no published accuracy benchmark to check it against.
• It costs real tokens. Five review stages with fresh-context reviewers, plus a brainstorm swarm, is a lot of model calls. The Cowork run hitting a usage limit mid-review tells you the shape of that cost. Budget for it, or the review will stop halfway and you'll have paid for half a review.
• Isolation leaks on some hosts. Issue #237 — host instruction files bleeding into reviewers — is exactly the kind of bug that quietly defeats the mechanism. Check your harness before you trust the review.
• Not officially supported. The README says so. If it breaks on your setup, the community is your support channel.
• It's slow by design. Ten minutes for a Codex review cycle is not a bug; it's the trade. If your features are small enough to hold in your head, this is overkill. EGM earns its keep on the features big enough that you can't.

How to try it

The repo is on GitHub under Google's open-source org, and the project site is egm.dev. Install the plugin in your harness of choice, then run the three commands on something real — not a toy project, a feature you actually care about getting right. Start with /egm-brainstorm and watch what the six lenses catch. The YAGNI lens alone is worth the install if you've ever watched an agent gold-plate a simple change.

If you're on Claude Code, check your version first — you need 2.1.271 or later. If you're on Codex, the test record says 0.163.0 works end to end. And if your harness can't spawn fresh subagents at all, don't bother: EGM will stop, and it's right to.

The bottom line

EGM is not a revolution. It's a process plugin with a memorable metaphor and one genuinely good idea: the cheapest place to find a wrong assumption is in a document, reviewed by someone — or something — that wasn't in the room when the assumption was made.

The test record is real but narrow, the token bill is real, and the isolation still leaks on some hosts. But the core bet is sound, and it's the bet every senior engineer already makes in code review: fresh eyes catch what tired eyes can't. Google just automated the fresh eyes.

Have you ever had an agent confidently build the wrong thing because nobody wrote down what "right" meant? That's the wound this is aimed at. I'd genuinely like to hear whether a spec-first pass would have saved your last bad PR — or whether the spec would have just been another document nobody read.

Sources: Google Open Source Blog — "Introducing the Elephant-Goldfish Model plugin: scaling design-driven AI software development" (opensource.googleblog.com); MarkTechPost coverage, 8 November 2026 (marktechpost.com); EGM repository and test records (github.com/google, egm.dev), checked 8 November 2026. All capability and adoption claims are Google's, stated as such. No hands-on testing was performed for this article. The README states EGM is not an officially supported Google product. This breaking article is not the daily buyer-intent post, and it contains no affiliate links.