EGM Design Review: What Fresh Context Can Reveal
A long AI-generated design document can still make sense only to people who took part in the conversation. The Elephant–Goldfish Model (EGM) plugin turns that into a review boundary: a context-rich session develops the design, while fresh review contexts examine the document and relevant source material. The point is to expose assumptions that never made it into the handoff, rather than obtain a correctness guarantee by collecting model votes.
Contents
- What a fresh-context review changes
- Zero context does not mean zero project evidence
- “The export endpoint supports retries” leaves decisions open
- Turn choices into executable acceptance examples
- Connect findings to states and real implementation locations
- Installation, offline tests, and live review are different evidence
- When this additional step is useful
Google’s Open Source Blog announced EGM on October 22, 2026. Using a pinned project version, this analysis works through a backend export-request example to show what makes a specification actionable and what a passing review cannot establish on its own. 中文版.
What a fresh-context review changes
The announcement describes two roles: Elephant retains design history, while Goldfish reviews without inheriting the earlier discussion. It describes comprehension, critical review, and implementation-readiness checks. The practical idea is to test a plan before coding by asking whether another reader can work from the material actually handed over.
This does not prevent the design session from questioning itself. It establishes another entry point for the final handoff. In a long conversation, “handle it as we discussed” can conceal an important decision. A reader without that discussion has to stop and ask for the decision, its rationale, and its exceptions to be written down.
The roles were checked against the README at repository commit d651fe86, an October 23 project snapshot. EGM organizes skills and review workflows in existing AI coding environments. Completing a review in a particular environment still requires execution evidence.
History, trade-offs, constraints
Explicit document
Document and referenced source
No earlier conversation
Restatement, counterexamples, readiness
Human resolves findings
Zero context does not mean zero project evidence
Reviewers still need the specification, explicitly referenced source material, and necessary constraints. What they do not inherit is the designer’s preceding conversation. The pinned environment guide requires actual fresh-context capability; telling the same long-running conversation to forget earlier content does not demonstrate isolation.
Without source material, a reviewer might assess textual consistency but cannot confirm that a named file or existing interface is real. Passing in the whole chat history can restore the original unstated assumptions. A useful handoff gives a reviewer the facts needed for the task instead of equating unfamiliarity with the project with independent scrutiny.
Fresh conversations do not guarantee statistically independent mistakes. A shared model family, similar prompts, or the same inaccurate document can cause several reviewers to miss the same issue. Agreement is not automatically a confidence estimate and does not replace execution or human business judgment. No model run or effect measurement of EGM was performed here, so no defect-reduction rate is reported.
“The export endpoint supports retries” leaves decisions open
Consider a fictional requirement: a user submits an export job and may safely retry if the network response is lost. The sentence sounds concrete, yet an implementer still needs to know who supplies the retry key, whether tenants share its scope, what happens when the same key carries different parameters, and what to return while the original job is unfinished. If those choices exist only in the preceding chat, a standalone document cannot support the implementation.
These questions need decisions, though not necessarily a complicated system. The teaching contract here uses tenant plus request key as identity. Identical identity and normalized parameters reuse the original job_id; changed parameters return 409; a missing tenant or key returns 400. First creation uses 201 and a replay uses 200. These are choices for this article’s example, not an HTTP API prescribed by EGM.
Once choices are explicit, a review can move from “consider idempotency” to concrete counterexamples. Could tenant A retrieve tenant B’s job through the same key? Would changing CSV to JSON return the old job? Could simultaneous arrivals create two jobs? Such questions are closer to an implementable design than another paragraph promising reliability.
201 → job 1
200 → the same job 1
409 → no new job
Turn choices into executable acceptance examples
The program implements only serial, single-process, in-memory request identity. Seven request scenarios plus one total-job-count assertion give eight passing checks under Python 3.15.0. A replay reuses job one, a conflict returns 409, and another tenant and a new key create jobs two and three. Reordering fields does not change recognition of the same object in this example.
import json
records = {}
jobs = []
def submit(tenant, key, payload):
if not tenant or not key:
return 400, None
canonical = json.dumps(payload, sort_keys=True, allow_nan=False)
scope = (tenant, key)
if scope in records:
previous, job_id = records[scope]
return (200, job_id) if previous == canonical else (409, None)
job_id = len(jobs) + 1
jobs.append(job_id)
records[scope] = (canonical, job_id)
return 201, job_id
cases = [
('first', 'A', 'K', {'format': 'csv', 'source': 'sample'}, (201, 1)),
('retry', 'A', 'K', {'format': 'csv', 'source': 'sample'}, (200, 1)),
('conflict', 'A', 'K', {'format': 'json', 'source': 'sample'}, (409, None)),
('other tenant', 'B', 'K', {'format': 'csv', 'source': 'sample'}, (201, 2)),
('new key', 'A', 'K2', {'format': 'csv', 'source': 'sample'}, (201, 3)),
('field order', 'A', 'K', {'source': 'sample', 'format': 'csv'}, (200, 1)),
('empty key', 'A', '', {'format': 'csv', 'source': 'sample'}, (400, None)),
]
for label, tenant, key, payload, expected in cases:
actual = submit(tenant, key, payload)
assert actual == expected, (label, actual, expected)
print(label, actual)
assert len(jobs) == 3
print('8 checks passed; serial in-memory contract example')
Suppose the caller did not receive the first response and resubmits the same parameters. The second scenario specifies reuse of the original job rather than another creation. No network request, packet loss, or actual export was run here. This is a reproducible acceptance contract, not output generated by running EGM.
Sorting JSON keys merely stabilizes dictionary field order for this example; it is not a complete cross-language request-canonicalization standard. More importantly, the dictionary has no database transaction, persistence, expiry, or queue-failure handling. Eight serial checks cannot establish that concurrent callers create only one job. A production design needs an explicit atomic boundary and checks for that boundary, including two callers entering while the record is absent.
Connect findings to states and real implementation locations
Putting this program into a design still leaves questions. How long is an idempotency record retained? What if the process exits after recording the request but before enqueueing work? Does a retry after completion return the existing job_id or a new result? These decisions change the contract and should not be left for an implementer to guess.
For each important choice, a handoff can name the current state, trigger, next state, and observable response. Then identify the files and interfaces responsible and how the transition will be verified. No actual application repository is involved here, so this article does not invent existing file paths. Adoption means filling in locations that really exist in the reader’s project.
A review record should retain the issue, evidence, resolution, and unresolved items. If a decision is deferred, explain why it does not block the current scope rather than deleting it from the report. Asking a new reader to restate the architecture can reveal comprehension gaps; readiness checking should establish that the critical decisions have moved from conversation into the document. A correct restatement establishes comprehension, not business suitability or readiness to deploy without tests.
Installation, offline tests, and live review are different evidence
The pinned testing guide separates offline unit checks from optional live execution checks. The former examine structures such as metadata, links, and paths; they do not by themselves establish that a real reviewer did not inherit the parent conversation. This distinction is more useful to adoption than simply seeing that a project has tests.
To assess an actual review run, examine the environment’s execution record: whether a fresh context was created, which allowed materials it read, whether the required stages finished, and which result was retained. A report file’s existence establishes its existence. When isolation evidence is unavailable, record isolation as unverified.
No plugin was installed, no multi-agent review was launched, and no model was called for a plugin trial. Execution evidence is limited to the original Python contract example. Plugin capabilities and limits come from pinned documents; their authors’ test records are not presented as this site’s measurements. Keep installation, workflow completion, context isolation, and design quality separate when trying the plugin.
When this additional step is useful
The approach is worth examining for changes involving important design choices, handoff, or several modules. A small fix with clear requirements may not need a complete design cycle. The project’s own workflow guide encourages using tools for the actual bottleneck rather than forcing every task through the whole process.
A backend developer can start with an interface involving retries, state, or failure recovery. Write the plan so someone absent from the discussion can implement it accurately, then verify explicit scenarios. The useful outcome is fewer decisions left to guess during implementation, not more document pages or reviewers. Real project records are needed to assess that outcome; no delivery-speed improvement is claimed here.
The earlier article on verifying AI-search completion claims asks what evidence should accompany a result. Design review needs the same discipline: a passing result should refer to a document version, unresolved findings, and an actual execution record before it guides implementation.
Sources are the October 22 Google announcement and the pinned d651fe86 README, environment guide, test record, and workflow guide. Diagrams, export-request contract, and program are original teaching material. The article retains October 23, 2026 at 11:30 Beijing time and was actually published as a catch-up article on October 28, 2026.
Support
If the explanations or examples helped you solve a problem or save time, you’re welcome to support this site with a voluntary tip.
Click a QR code to enlarge. More options: support page。


