EGM: Google's New Way To Use Claude Code Is Insane

0:00There's a new way to vibe code by Google called the elephant goldfish model, and it's built to catch problems before your agent builds anything. Usually, when you ask your agent to build something, it just builds it, and you only find the problems after. But with this one, your agents work gets torn apart first. The elephant and the goldfish in the name are two different kinds of agents, and the names tell you exactly how each one works. And the way Google keeps those

0:24two apart is what makes it different. Out of all the other workflows we looked at, only one does anything like it. We tried it on our own app with a new feature and it caught a real bug that the usual review missed. If this is your first time, we're a software company and this is our channel, AIAs. And in this video, we're going to show you what the elephant goldfish model is, how it works, and how to use it on your own app. Now, the elephant goldfish model is Google's way of thoroughly planning what you want to build before you actually build it. It's Google's take on

0:53specdriven development where you write down the complete plan for your app first and then the agent builds the app by following that plan. It was developed by engineers at Google and it's based on an article written by Dave Renson called Elephants Goldfish and the new golden age of software engineering and it's free for anyone to use on Google's GitHub. It uses multiple agents and skills to basically plan your app in a way that leaves no angle untouched and leaves your plan complete without any gaps in it. So that when your agent is implementing the plan, it doesn't have anything to guess while building because everything is documented which makes it

1:28easier to build on top of. And you don't just get a plan, you also get a checklist of what needs to be built and how to test it to make sure everything works the way you wanted. That way you know the feature is complete. But before we go install the tool, let's understand the core philosophy of this model. This model works around two roles, the elephant and the goldfish. Just like their name suggest, the elephant represents the part of the workflow that

1:50remembers everything about the project. It knows the whole history of your project, how your app is actually put together and what people use it for. This is the part of the workflow that's responsible for actually talking through the idea with you in depth, thinking about it from different angles, seeing where it might fail, and writing the detailed planning files that form the base of the plan. The second part is the goldfish, which is the part of the

2:13workflow that doesn't remember anything. These are sub agents that have zero context. They only see the plan and your app's code, and they never see what you and the main agent talked about. So, nothing you said earlier can influence them in any way. The goldfish look at the plan differently from the other agents. There are multiple angles they look at the plan through. One checks if there's an easier way to do it than the plan says, or if your app already has something that does the job. Another reads it like someone who knows nothing about your app and checks if it still makes sense. One looks for issues that

2:43come up when the app reaches a lot of people and they all use it at once. And another checks if the plan is clear enough that a model could build it without having to guess anything. A couple more check how the plan itself is written and set up. The elephant and the goldfish work together to create a final plan they both agree on and the other agents use that plan as their starting point. Now, you might think that most agents already have a plan mode. So, why would you need to go through this whole process at all? When you plan something with your model, it usually goes like

3:12this. You explain your idea. It asks you a few questions about the major details it can't decide without your input. And then it writes the plan. That plan misses details and issues that come up later on. And you then have to revise it again to deal with those issues. This model lets you have a complete plan that's been analyzed from every angle and doesn't leave any gaps so that when you're working, those issues don't come up no matter how many people are using the app. The other benefit comes from the goldfish. When you use the plan mode, most of the work happens in the same chat. This matters because the

3:43agent already knows what you discussed about the plan. So when it checks the plan, it basically just agrees with itself. Google says the main problem with models is that they stick to their own wrong ideas and agree with what you want instead of catching mistakes. That's why the goldfish is not allowed to see your chat. But all of these sub aents give you a lot of notes. And that's where the third role comes in, which is you. The model comes up with ideas and checks the plan, but you're

4:08the one who makes the final calls. Google says the review gives you a lot of notes on purpose, so you keep what's useful and ignore the rest. The sub agents grade the plan using a set of written rules that act as checklists of what a good plan should have. And this review uses one sub agent that starts a set of other sub aents. This keeps the main agents context from getting bloated by all the reports the other agents write. And that one agent then combines them into a single report, which is the only one you review. And even after the

4:36feature is built, the plan helps a lot. Later on, a check called Drift compares the plan with your app and points out every place where they no longer match. Then you decide which one to fix. But before we install it, it would be great if you subscribe to the channel and hit the hype button. This small gesture of support goes a long way for us. Now, this tool is available for whichever agent you use, whether that's Claude Code, Codeex, or any other. The repo has a separate install command for each one, and you can copy whichever one you need, or you can just copy the install prompt

5:06from their website, which is just the word install followed by the link to the repo and paste it into your agent. When you send that prompt, it runs all the steps to download the repo and set it up in your project. Since we were using Claude Code, it also wrote a cloud. MD file so it could put the instructions for this tool in there. And there's one line in that file you'll want to check, which we'll get to in a second. When it's installed, you'll find three new folders inside your do.claw folder. One of them is called agents, and it holds

5:33all the agents that the method uses. These are the goldfish in the method that we talked about earlier. The second folder is EGM, which is just a full copy of the repo. And there's a skills folder too, which holds all the skills that run each step of the method. These are the elephant part of the workflow. The main one is the brainstorm skill, which basically takes your idea and turns it into a clear plan of attack. It asks you lots of questions and keeps going until the problem is clear. There's also a review skill that starts the goldfish review. It has all the steps for reviewing your plan and calling in the

6:05sub aents. But like we said, the install also writes some instructions into the claw.md file. So the line you'll need to check is near the end of this file and it says that claude codes sub aents can't start sub aents of their own. That's because older versions of Claude code couldn't do that. So, it wrote that from memory. But the new version of Claude code actually lets a sub aent start other sub aents unlike what the line says. So, when we asked about this, Claude said it had written the claude.md file on its own and that no step in the repo had told it to write it. We told it

6:37that line was wrong and that the review sub aents can start their own sub aents. So, it tested it and when it saw that it does work in clawed code, it changed that line so the method could run the way Google meant it to. You might not run into this because they're updating the repo pretty often, but that's what happened when we were recording. So, it's worth checking that file. If you see a line like this in your claude.md, ask Claude to fix it, too. Or you can just copy the install command for the specific agent you're using, and it will install it directly for that agent

7:06without any conflicts like this. Now, we tried this on a demo fashion app that we had already built. Most of the app was done and we were just adding new features to it. The one we wanted to add was a page that shows each seller which sizes are selling, which ones have sold out, and when they should restock. The workflow actually starts with brainstorm. But before we move on to that, we need to run another command. We

7:27need to run the EGM bootstrap command. This command tells the elephant everything it needs to know about the app and how it works before it can plan anything new on top of it. This command goes through your app one folder at a time and writes a readme file for each folder that explains what the code in that folder does and all the rules it has to follow. But before it starts, if your app has more than 15 folders, it will check whether you still want to write the full mapping or not. It does that because writing readme files for that many folders takes a lot of sub

7:57aents. So it checks with you first whether you want to do it or not. So we told it to keep going and it got to work. It started sub agents and each one worked on a different part of the app. When they were done, they wrote the readme files. In our case, it wrote 28 new readme files and also updated the main readme file we already had. So, in your main readme file, there'll be a new section that wasn't there before. It lists what each part of the app does, the rules that always have to stay true, and what changes when it runs. Every folder that has code in it gets its own

8:26readme file. It tells you what the folder is for, what's inside it, what each part does, and how the parts connect. The folders with no code in them don't get a readme file. For example, we had a specs folder with the plans we used to build the app, so it didn't get one. But there's a problem

8:40with it writing the files as readmes. These files are written for people to read, not for other agents. So agents don't normally read them unless you tell them to. That means if this command only writes readme files, claude code won't read them on its own. There are three ways to fix this. First, you can add a claw.md file next to each readme file and tell it to check the readme file, too. If you're using codecs, you can use an agents.md file instead. Second, you can run the bootstrap command again and add a setting that tells it to create claw.md files from the start. Or third, you can add a line to your main

9:14claude.md file, telling it to read the readme file in every folder it works in. We added a claw.md file next to each readme to make sure Claude follows them correctly. Now, once the readme files are done, you can move on to the next step. But first, let's have a word by our sponsor, Hedra. Now, if you want to make a video for your app, but don't know what to say or show in it, you can

9:34ask Hedra to help you figure that out. We gave it our app's details and asked it to research who the promo should be for. It found sources and suggested what to focus on, then ask questions about the video. The agent updated our brief and storyboard, which lay out the message and what happens in each shot. They're on the canvas next to our chat inside a space which keeps the projects work together. We read the brief then asked Hedra to make the promo. It asked for approval before generating a logo and a reference image of an office

10:01worker to guide how the video looks. Then it used those images to make the video. We played the promo inside Hedra ending with our logo. So if you need help figuring out what your app's promo should say, try Hedra free through the link in the description and use this code for 50% off your first month. And once [snorts] Bootstrap is done, the

10:19next step is to actually start building. All the steps are listed in the GitHub repo and you can run them one at a time. The first step is to run the EGM brainstorm command and tell it the feature you want to add. When we did this, it found that we already had a written plan for this feature. It pointed out everything wrong with that plan and then asked us a bunch of questions. If you don't already have a plan like we did, it'll ask you even more questions. You just need to keep answering them and when they're all answered, it gives you its best guess for how to build your feature. Then it

10:49gives you two choices. The first is to review it with the goldfish, which runs six goldfish that each look at it in a different way and then writes up the idea in a file called the concept brief. Or if you don't think its approach is right, you can explain more in the chat. We thought it was good enough, so we chose to review it with the goldfish. It starts one sub agent, which starts six more in the background. Each one starts

11:11fresh and knows nothing about your chat. When they're done, it writes the concept brief file. This file is in the main folder of your project. It explains the feature, what it found when it looked into it, what's standing in the way, and everything that needs to be done. You can read it to see if it matches what you want. You can ask for as many changes as you like. But if you're happy with it, the next step is to run the EGM draft command. This command takes the concept brief file and writes the first version of the plan called the design draft. It explains the feature, the

11:40problem it solves, and what it will and won't do, so nothing gets lost. It also lists the main paths a person takes through the feature, which are called critical user journeys. So, we can write tests against them. So, you'll need to approve this file, and when you do, it makes changes to it. It writes the plan one part at a time and waits for your approval after each one. So, you can steer it before the next part gets built on top of it. Next, it adds the technical plan, which is how the feature will actually be built. When you approve it, it adds a section called

12:09alternatives considered that lists the other ways the feature could have been built with the good and bad sides of each and why they weren't picked. When you've read the alternatives, it moves on to the step-by-step building plan. It keeps updating all these sections in the design draft file. And when it's done, it saves a file named after the feature in the designs folder inside the docs folder. That designs folder is where every feature you build this way gets saved. and it's what you'll be asking your agent to build from. But this whole plan was written by the same agent that's been agreeing with you this entire time. So before anything gets

12:42built, it goes to the goldfish. To do that, you need to run the EGM review command and it starts with a sub agent called zoom out. It checks if there's an easier way to build the feature or if the app already has something that does the job and it knows nothing about your chat. When this sub aent is done, it writes a report with a list of all the big problems. The review happens in rounds and in each round the plan gets checked in one way and the sub agent reports what it found. After each round you can move on to the next one or ask

13:10for changes. There are five rounds of review in total and the tool numbers them from 5 to 9. After each one it writes a report for that round and updates the plan in the designs folder based on what it found. You can ask for fixes wherever you need them. And when all the rounds are done, you end the review. It then changes the plan status from in review to proposed and marks the review as finished. So basically what you end up with is one file in your docs designs folder that you use when you ask for the feature to be built. You can open a new chat and ask your agent to

13:41build the feature in this file and it gets to work. This way the tricky cases get worked out before anything is built and the result is much better because Claude has clear rules to follow. But once the feature is built, your app keeps changing and the files don't. So, it also has a command that checks if any part of your app goes against the readme files. To use it, you just run the eGM drift report command and it asks you how much of the app you wanted to check. We asked it to check against all the readme files and it started two sub aents to look at different parts of the app. When

14:11both of them came back, it made a full report showing what had changed and where the app and the readme files no longer matched. It even caught real bugs in the code. For example, in our app, shop owners could delete products that had already been sold, even though the rule says a product that has sold can only be hidden, not deleted. It listed everything it found, and you can ask it to fix the problems in each part of the

14:33app, which makes your app much better. Now, this workflow is actually good if you're planning a large feature that's going to cost you a lot if it goes wrong. That's because it went through the edge cases and possibilities more deeply than the other ways we've tried. But even though it's good, that doesn't mean you should use it for everything. Google says it isn't worth it for a

14:51small fix your agent can do in one go. Because on small changes, all this planning and reviewing just slows you down. And this isn't the only way to plan with agents. There are a lot of others. With most of them, you do get a written plan. But finding out what's wrong with them is a hard part. With

15:06this one, the goldfish finds it for you. And since they never see your chat, nothing you said can talk them out of it. Out of the ones we looked at, only few others do something like that. And after you've built, this one can go back over your whole app and tell you where it no longer matches the plan, while the others mostly check one feature at a time right after you build it. So even though it takes longer on the features that matter, it's worth using. Now, we've made a simpler version that does the same thing, but without going as in-depth as the original does by

15:34default. So, if you found value in what we do and want to support the channel, this is the best way to do it. The links in the description. That brings us to the end of this video. If you'd like to support the channel and help us keep making videos like this, you can do so

15:47by using the super thanks button below. As always, thank you for watching and I'll see you in the next one.