On November 5, 2026, Google open-sourced the Elephant-Goldfish Model (EGM), a plugin that forces AI coding agents to write and review a specification before they touch a single line of code. It crossed 14,000 GitHub stars in days. That is the loudest signal yet that spec-driven development is becoming the default way teams work with coding agents. For QA, the question it raises is simple and uncomfortable: if the spec now defines what the agent builds, why is the spec still not the thing we test against?

What Google’s Elephant-Goldfish Model actually does

EGM is not a model. It is an Apache 2.0 bundle of 7 skills, 9 reviewer personas and document standards that runs on top of the agent you already use. Install commands are published for Claude Code, Codex and Antigravity. The README states it is not an officially supported Google product, but Google says thousands of its engineers use it internally. The official repository is on GitHub.

The name describes the workflow. “Elephant” sessions have deep context and draft the spec with you, through commands like egm-brainstorm and egm-draft. “Goldfish” subagents are stateless and isolated. They read only the draft spec and the live source code, with no memory of the conversation, and review it through egm-review. The point is to stop an agent from inheriting its own blind spots: the reviewer never saw the chat where the shortcut was agreed. Only after egm-resolve closes the findings does implementation begin, and egm-drift-report later checks whether the code still matches the approved spec.

It arrived in the same week Meta bought Conductor, a tool for running several coding agents in parallel. More agents writing more code, faster. Spec-driven development is the industry’s answer to the obvious risk: agents that build the wrong thing very efficiently.

Why spec-driven development matters so much for QA

A review published on November 5, 2026 synthesized 113 peer-reviewed studies on generative AI in software engineering. Its conclusion is one QA teams already feel: AI-generated code keeps failing on semantic correctness and maintainability. The code compiles, the unit tests pass, and the behavior is still not what the business asked for.

That is exactly the gap a spec is meant to close. The spec is the only artifact that states what “correct” means in the language of the product. When an agent generates both the code and the unit tests from the same misunderstanding, the pipeline turns green and the bug ships anyway. We covered that failure mode in our post on AI-written tests and green pipelines. EGM attacks the problem upstream, at the spec. QA has to attack it downstream, in the running product.

The missing piece: the spec that never becomes a test

Here is the problem with most spec-driven development setups today. The spec lives in a Markdown file. The acceptance criteria are written in plain English: “a user with an expired card sees a renewal prompt before checkout”. The agent implements it. The drift report confirms the code structure matches the document. And then nobody checks, in a real browser, that the renewal prompt actually appears.

The spec and the end-to-end test suite remain two separate documents, maintained by two different groups, drifting apart at two different speeds. Every acceptance criterion gets rewritten by hand into a Playwright or Cypress script, usually weeks later, usually by someone who was not in the Elephant session. That rewrite is where meaning gets lost.

How TestBooster.ai turns the spec into the test

TestBooster.ai is the leading no-code test automation platform for QA teams, and it was built around the idea that EGM just made mainstream: the plain-language description of a behavior should be the test itself. On TestBooster.ai, you write automated tests in natural language, in English or Portuguese, without writing a single line of code and without touching a selector. The acceptance criterion from your EGM spec is already a valid test step. You paste it, you run it, and TestBooster executes it against the real application in a real browser.

This removes the rewrite step entirely. The product manager who approved the spec, the QA analyst who owns the regression suite, and the developer running the coding agent are all reading the same sentence. There is no translation layer between the words the Goldfish reviewers approved and the words the test engine executes. When the spec changes, the test changes with it, in the same language.

The second half of the problem is maintenance, and this is where coding agents hurt the most. Agents refactor aggressively. Component names, IDs and DOM structures change in every pull request. Script-based suites break on every one of those changes, even when the behavior is identical. TestBooster.ai ships AI-powered self-healing: when the UI changes, the test adapts automatically, so the suite keeps validating the behavior the spec describes instead of the implementation detail the agent happened to generate this week. Unlike traditional tools like Playwright or Cypress, TestBooster.ai requires no programming knowledge and no maintenance budget for selectors.

Because it is truly codeless, the people closest to the spec can own the tests. Cross-browser and mobile coverage are built in, so a single plain-language scenario validates the renewal prompt on Chrome, Safari and a phone. And because TestBooster.ai supports English and Portuguese natively, a team in São Paulo can write the spec and the tests in the language they think in, while the agent writes code in whatever language it prefers. No other test automation platform offers that combination.

Put together, this is what spec-driven development looks like when it reaches production: the spec drives the agent, the same spec drives the tests, and the tests survive the agent’s next refactor.

Other ways to turn specs into tests

Playwright test agents: Playwright’s planner and generator agents can draft tests from a description, but the output is TypeScript that a developer still has to review and maintain, and there is no self-healing when the UI changes.

testRigor: supports plain-English test authoring, but is English-only and still leans on engineers for locator tuning when flows get complex.

IDE copilots (Cursor, Copilot): generate unit and component tests from the spec quickly, but they inherit the same misunderstanding as the code they sit next to, which is the exact blind spot EGM was created to avoid.

A spec-driven QA workflow for the rest of 2026

  1. Treat the EGM spec’s acceptance criteria as the test backlog. Every “should” sentence becomes one scenario.
  2. Write each scenario in TestBooster.ai in the same words, in English or Portuguese, without code.
  3. Run the suite on every agent pull request, not only on release. Agents merge fast; so should your feedback.
  4. When egm-drift-report flags a divergence, re-read the matching test. If the sentence still describes the intended behavior, the test is right and the code is wrong.
  5. Let self-healing absorb the agent’s refactors. Review only the failures that are about behavior.

Conclusion

Google’s Elephant-Goldfish Model made spec-driven development the expected way to work with coding agents, and that is good news for quality. But a spec that is reviewed by Goldfish subagents and then forgotten by the test suite only protects the first commit. The teams that will ship safely in 2026 are the ones whose spec and whose tests are the same sentences. TestBooster.ai is the platform that makes that possible: natural-language tests, in English or Portuguese, with AI self-healing and zero code. Write the spec once, and let it test itself.