Zoo 3.1 fights scope creep and runs on Grok

Zoo 3.1 + Grok 4.6 = ❤️ nirvana ❤️

With GPT 5.6 Sol, Codex has quickly drifted into la-la land. It is so intelligent that it writes specs and commits that nobody wants to read, and sees so many edge cases that any small change turns into a never-ending stream of new discoveries to fix.

A few tasks executed by Sol + Zoo 3 have been sitting in my review queue for weeks, because they’re essentially not reviewable.

Fable is better at specs, although sometimes still too smart for its own good, but doing a single task eats 50% of your weekly limit.

Something had to be done! And that something, of course, is Zoo 3.1.

Scope

The big change is strict adherence to the scope of the user request. Any scope extensions are collected as suggestions and require user approval.

Duh! But I have really, really tried to push the boundaries of AI autonomy, went all the way to the ‘fully autonomous’ side with Zoo 2, and then cautiously stepped back just enough to maintain control while keeping agents moving swiftly.

Spec now also has “False positives” and “Out of scope” sections to discard wild ideas with prejudice.

Reviewability

Turns out, being able to review the agent’s work is not optional. :/

Zoo 3.1 focuses on making this as easy as possible. The spec has been reorganized to focus on providing the right level of detail to the user and make reading it quick and pleasurable.

Subtask and commit guidance has also been tweaked for reviewability, to produce:

• small, easily reviewable commits;
• with commit messages explaining why each change had to be done, and how it fits into the overall task;
• without any accidental or unrelated changes – even review findings go into suggestions (or future subtasks) unless directly touching the modified code within the scope of the subtask.

Instructions also emphasize that any changes must now run as part of a subtask, with the corresponding workflow steps ending in a commit. This helps with further commit separation during reviews and revisions.

Two-stage planning

Here’s how the workflow now looks:

1. High-level planning (with a spec review and optional uber-review). Just enough to settle the approach with user input, without spending time on code-level details. Explicit user approval to move on.
2. Low-level planning (names, edge cases, per-package/file change summaries, logging and similar). Explicit user approval to move on.
3. Fully autonomous execution without expanding the scope.
4. After doing all it could, the agent reports back to the user, asking about any suggested changes to the scope.

Previously, this would have been a nightmare; with a new spec format plus Grok, those spec reviews are actually pretty quick.

Grok

Meanwhile, I’ve discovered Grok 4.6 which:

• handles complex tasks well but is not clinically insane;
• authors readable specs in a perfectly normal human language;
• is so much faster than even Codex in fast mode;
• picks up Claude skills and subagents out of the box;
• stretches weekly limits forever (esp on SuperGrok Heavy);
• does not refuse security reviews and security work;
• Grok Build is such a pleasant tool, and clearly built by people sharing my values in software (which is a striking turn of events); I’d prefer a GUI app, but it is a very, very, VERY good cli that puts Codex and Claude to shame.

Uber-reviews are back in town

I figured those brains the size of the planet should still contribute something to my projects. Hence, cross-agent spec uber-reviews.

Run /zoo-spec-uberreview to use all other installed agents to review the spec, and your primary agent will collect and sort that feedback (and Grok is very good at sending some of the crazier Codex ideas into “False positives”).

Driving Claude Fable and Codex Sol reviews from Grok turned out to be super smooth:

• valuable tweaks are often made to the spec;
• anything big they find goes into suggestions and is sent for immediate user decision, so they cannot balloon the scope;
• Grok is good at putting their craziness into “False positives” and moving on, but is also good at incorporating useful ideas;
• this costs hardly any limits with Codex, and low single digits with Claude.

Running Claude and Codex occasionally also serves to remind me how slow they are compared to Grok.

Uber-reviews are only for the specs; with scope fixed, the implementation is now the boring part, and cross-agent code reviews do not seem worth it. Suggested scope changes go into the spec, so after implementation is done, you can re-run spec uber-review if you’d like other agents’ opinions.

For now, uber-reviews are strictly manual.

Scripted reviews

Zoo 3 introduced support for deterministic checks. Turns out, if you ask agents to answer each question from a list, they are much more diligent at reviewing details.

That support is unchanged (upgrading it will likely be a big focus of Zoo 3.2), but Zoo 3.1 now brings back general agentic spec and code reviews based on the same idea: compile a list of questions and pass it to a subagent (or another agent in case of uber-reviews).

Zoo 3.1 has a built-in list of review questions and so will do useful reviews out of the box. You can, of course, provide your own questions.

Investigation mode

Say Investigate <problem> with Zoo and the agent investigates the bug deeply before writing a high-level plan, and can even say that no code changes are needed and the problem is elsewhere.

New skills

Zoo Squash (“tidy up my patchset”) prepares your unpushed commits for pushing. Three modes: squash everything into one commit, rewrite the messages without squashing, or format a patchset: fold rework and review fixes into the commits that introduced the code, so the patchset builds up the functionality without false takes, topped with a final commit describing the whole changeset.

Zoo Upgrade Spec updates old spec files to the latest format.

Installation

Ask your agent to install all skills from the Zoo repo, and run Zoo Init. Note that Codex skills now live in .agents/skills (the Codex repo skill path), and the installer cleans up old copies.

If you’ve been running an older version of Zoo, run Zoo Upgrade Spec to modernize your in-progress spec before continuing.