
Google recently released the 'Elephant-Goldfish Model (EGM)' plugin.
EGM utilizes two types of AI sessions. The 'Elephant' is a long-term session that remembers the overall project structure, development context, and prior decisions. Rather than writing code directly, it discusses requirements and technical choices with the developer, then produces a markdown specification containing a concrete implementation plan.
The 'Goldfish' is an independent sub-agent with no prior conversation history. If the same AI handled both design and review, it might simply accept flawed initial assumptions as given. The Goldfish receives only the specification and reference files instead of past conversations, so it can independently identify problems in the design. Multiple Goldfish agents examine potential errors, edge cases, and hidden dependencies from different perspectives, then report their findings back to the Elephant session.
The idea is to supplement the specification system, and many people argue that you should run parallel agents on top of it.
That sounds appealing, but I'm not particularly enthusiastic about the idea of running AI agents in parallel.
The reason is that it destroys causal continuity.

I always think of AI-generated code as analogous to this kind of drawing. The picture above looks remarkably well done at first glance, yet it contains quite a few mistakes: a missing thumb, a strangely shaped gun barrel, and so on.
AI code is exactly the same. There are errors that are hard to catch unless you look carefully, and when a large volume of information comes in all at once, spotting those errors is not easy. Parallel agents are dangerous precisely at this point. Reviews from multiple perspectives can reduce errors, but when several streams of implementation pour out simultaneously, the developer's review debt gets parallelized right along with them.

AI code can be like this gun drawing. If you look closely you notice that the muzzle structure is wrong, but when a large amount of information comes in all at once, it's not easy to catch.
People believe that if you give an AI a sufficiently good specification along with UML and SPEC documents, it will produce a good implementation.
And as the volume of code an individual must handle keeps growing, AI has become essential. To put it plainly: an individual developer used to have roughly 40,000 to 60,000 lines memorized. Beyond that, things would be forgotten through the natural course of work or simply hit the wall of cognitive limits. I tend to check the flow within that range, but with AI-generated code you can push that boundary somewhat further, to around 100,000 lines.
This kind of knowledge compression actually happens frequently once you get used to it. For instance, I may not be able to recall the academic definition of idempotency, but I do have a rough sense of what code satisfies idempotency and what doesn't.
Most programming works this way in practice. The first few times you encounter a concept you have no idea what it is, but after writing a few example programs and making some mistakes, you form an experience like, 'Oh, so this is what that kind of code looks like, and this is the shape it needs to take.'
As experience and time accumulate, you end up building your own reusable code blocks, and trusting those blocks, you gradually tackle larger programs.
As the details of implementation gradually fade from memory, what remains is a rough sense of what a given code shape and flow satisfies. And in the process, you lose the ability to read code shape and flow at a fine-grained level, yet a different ability develops in its place. I'm someone who believes there are real cognitive limits to what a person can hold.
Even so, with a single agent, the human is the one typing, and the work happens on top of a consistent continuity of what prompts were entered for each small task at the moment. So at least the sense of flow remains.
The problem is that the experience of parallel agents interferes with even grasping that flow of information.
The reason you can manage a 100,000-line system without typing the code yourself is that those lines were generated on a single time axis under one consistent context. Even if I've forgotten the detailed implementation, the broad flow of 'this data travels through that pipeline and gets transformed here' β the topology of the system β stays in my head. I lose the fine-grained sense of syntax, but at least the shape itself is something I can sketch out mentally.
Parallel agents and software factories, however, cut apart that last stronghold: causal continuity.
I believe AI writes code blocks better than humans do. Not better than everyone, but I think it writes small code blocks significantly better than most people.
Yet combining well-written code blocks doesn't automatically make a program, and in the end a program exists for humans. Can the result that an AI agent assembles actually fit human needs? I genuinely don't know.
AI code tends to be overly explicit, and it often surfaces even the implicit assumptions that humans would just take for granted. With UI code, for example, things a human developer would naturally leave implicit get laid bare whether you like it or not. AI code conveys far more information than human-written code. If all of that runs in parallel, can you really understand it? Can knowing the specification alone count as knowing the whole program?
Coming back to EGM: in theory it's impressive. Five Goldfish receive the specification simultaneously, review it from different perspectives, and return their findings to the Elephant. The Elephant then synthesizes those five pieces of feedback and adjusts the implementation direction. So far, so plausible.
But at the moment of that 'synthesis,' what exactly is happening inside the developer's head?
I had originally been thinking of a pipeline called A: the flow in which data enters, gets transformed, and exits where it needs to go. When working with a single agent, I say 'add this field here,' and the agent adjusts one span of that flow. I can at least intuitively trace what effect that one-span change has on the overall flow.
But when three Goldfish simultaneously raise different warnings β 'exception handling is missing at this point,' 'this circular dependency is dangerous,' 'this interface will block future extensibility' β the Elephant produces a revised proposal that incorporates all three at once.
Is that still the program I was following?
There's no guarantee the three changes don't interfere with each other. Fix one, and the premise of another may shift. Yet I don't know what causal path each of those three took to reach its conclusion. The Goldfish has no prior conversation history. All I see is the result the Elephant tells me it has 'synthesized.'
Adding more reviewers may surface more problems, but that doesn't automatically verify all the new interactions that arise in the course of resolving those problems.
In the end, I receive a finished specification and have to work backward asking, 'Wait, how did this end up this way?' With a single agent, the context I built up prompt by prompt means I can immediately think, 'Oh right, that earlier request is why it turned out like this.' With parallel agents, that's not possible. At the point where five causes converge into one result, I can no longer reconstruct the causes.
I also think it's an illusion that a perfect specification means you can perfectly control AI.
The reason I can handle 100,000 lines isn't that the specification for writing those 100,000 lines exists inside my head. It's simply because I went through the process of those 100,000 lines being created.
I started from an empty file. I remember why this module was needed. I remember why that interface was written the way it was, and which bug I hit at the time that made me change direction. It's not the shape of the code I'm remembering β it's the time during which that code took that shape.
Experience and accumulated time come down to exactly this: not memorizing the academic definition of idempotency, but ingraining the intuition that 'code of this shape is safe to call again,' and that intuition can only exist within a single continuous axis of work.
In a sufficiently large project, developers can designate a core lead contributor for each module to keep things in check, but solo developers cannot do that. On top of that, how can you trace every cause and effect in AI-driven development? In a community project, community members hold that information and can merge it together, but in an AI project, that's simply not possible.
I cannot understand the obsession with productivity. An excessive fixation on productivity is itself the root of the problem. Production must be connected to consumption. Consumption comes from having space and time.
And it is in consumption that we discover the genuine human need. If you don't use something, you can't know why you should produce it. You grow food because you're hungry; you try to improve something because you feel the inconvenience yourself and see it in others.
Is software truly scarce right now? No. If anything, even solo developers are cramming in too many features.
If there's no time to read and absorb AI-generated code, how are you supposed to find the next layer of need?
The biggest problem with productivity obsession is that it stops you from thinking about consumption. And consumption demands time: the time to read the code AI produces, to doubt it, to work backward asking 'why did this end up this way?' That time cannot be parallelized. You can run five Goldfish, and the Elephant can synthesize those five well, but the work of digesting that synthesis still happens on one person's sequential, linear time.
I often think about what a specification actually is. What makes a good specification? What makes a good program? In my experience, even a good specification will reveal problems and broken assumptions once you actually use the program β without exception. Specifications matter, but they are also the thing that changes most. If I'm not the one integrating the pieces myself, I lose the ability to respond to changes that come afterward. Can you really call that a good program?
I can't even keep up with my own consumption using a single agent, so I genuinely don't understand the people telling me to go parallel. I'm not sure whether I'm just slow, or whether the world is just changing too fast.