In 30 Sekunden
Instead of constantly choosing the “best” AI model for each task, Theo Browne uses different model families to review the same change. His council workflow lets reviewers inspect and test code, score it, and send feedback to the coding agent before he sees the pull request. He says it caught deleted regression tests and guest-sharing security flaws, but also reports runaway loops that consumed hundreds of subagents and inflated a change. His proposed safeguards are a review limit and explicit resistance to scope creep.
- 1Different model families can find different problems in the same changeBrowne’s council asks models with different training to review a change rather than trying to select a perfect model for every job. He says their distinct approaches regularly surface different issues.
- 2Reviewers score the work and can ask for another roundA coding agent delegates review to several models; a chosen score threshold can determine when the work returns to the user. Browne’s full-stop workflow stops before the human merges.
- 3His reviewers’ scores rose over repeated roundsFor changes with at least two scored rounds, Opus’s mean rating rose from 7.4 to 8.9; Muse and Sol rose to 9.1. These are the models’ own review scores for his work.
- 4Reviewers found three guest-sharing security flawsBrowne says review caught access to rolled-back HTML, stale content after revocation and a race between session checks and reads.
- 5Let reviewers run and test the change, not just read the diffHis agents can use the working computer, ask the implementing agent questions and validate behavior before a pull request is ready.
- 6Unbounded review loops can consume huge resources and inflate a changeOne thread spawned over 600 subagents and grew a roughly 1,000-line pull request beyond 20,000 lines. Browne wants a round cap and explicit limits on scope creep.
- 7The goal is to interrupt the human when the code is readyBrowne wants agents to verify their own work before presenting it, reducing the need to watch and steer every intermediate step.
Das Wichtigste
- Use different model families as reviewers on the same difficult change, rather than continually routing each task to a preferred model.
- Give reviewers access to the running code and a way to question the implementing agent.
- Set a review target and a maximum number of rounds; stop if the work is going in circles.
- Watch token consumption: Browne says his review loops exhaust a $200 subscription’s weekly allowance in two or three days.
- Treat model scores as the reviewers’ own ratings of a change, not as independent proof that it is safe.
Den bearbeiteten Text nach Kapiteln lesen
Multiple models without constant manual switching
Browne describes using several models on the code he ships. His tstack skills build on ideas from pstack while using his own subscriptions and workflow.
I use many AI models, but I do not recommend constantly switching between them or building elaborate routers to select the “right” model for every task. Most of the code I ship now involves multiple models in a different way: they contribute distinct perspectives to the same work.
I drew inspiration from pstack, a set of skills created by Lauren Tan, also known as Poteto, for working across models on ambitious tasks. My own tstack takes ideas I liked and adapts them to my day-to-day work and the subscriptions I already use. It includes full-send, full-stop, sol-loop and council.
As I have written more code with these tools, I have found differences between models and between the skills that invoke them. The distinction matters to the review workflow I have built.
Council reviews across model families
Council brings different models to the same change and uses a score threshold to decide when to stop. Browne explains how his agent harness delegates reviews and records scores.
The skill I want to focus on is council. People using it report different experiences: some find it excellent for review, while others find the usage cost too high. I have found it powerful, but there are important catches.

The basic idea is to ask models from different families to give feedback on one change. I think models in the same family can behave similarly, so using several of them may resemble asking the same reviewer at different times. My goal is to bring genuinely different approaches into a difficult review.
I still rarely switch away from my default coding model once I have chosen it, except when I have usage available on another subscription. I am not suggesting a permanent rule such as using one model for data, another for interfaces and a third for prose. The interesting part is combining their perspectives on the same work.
I first built council to compare the feedback from Muse, Sol and Opus. In my work, each has found useful things the others missed. The differences also helped when reviewing interface designs: one model might give a design nine out of ten while another gives it five.
The workflow needs a primary agent in a harness able to call other models for review. I typically ask reviewers for a score from one to ten, where one means discard the change and ten means they can see no reason not to merge. I choose a minimum score based on the task.
For example, I can request a change and append “full-stop with council 9.5.” Full-stop tells the agent to do what it can to verify the change and prepare a pull request, but to stop before merging so I can inspect it. Council adds the requirement that every reviewer reach the specified score before the agent considers the work done.
In T3 Code, one harness can call another, so the primary agent can launch Claude models through Claude Code, OpenAI models through Codex, and Muse through its own harness. The review scores are recorded on the pull request so I can see which models looked at it and how they rated the work.
I also sometimes include Gemini as an additional reviewer, while treating its score differently in my setup. Some problems I encountered were related to an incomplete integration between Gemini’s agent protocol and T3 Code; I say that integration is being improved.
The value of these reviews must be weighed against their token consumption. Before council, my simpler sol-loop paired Opus as the implementer with Sol as a thorough reviewer; the two would exchange changes and feedback until they agreed the work was good.
Review scores and bugs caught in practice
Browne presents his own reviewers’ scores over multiple rounds and examples involving test deletion, guest sharing and failed interrupts. Reviewers can run the code and talk to the implementing agent.

I examined council runs from my own work. For pull requests with two or more scored rounds, Opus’s average rating rose from 7.4 to 8.9 out of ten. Muse rose from 7.7 to 9.1 and Sol from 7.6 to 9.1. Opus had often written the code it initially rated most harshly, so even a separate self-review can change what the model finds.
Across 144 reviewer scores, 21 began below seven and only two remained below seven at the end; 128 ended at nine or higher. These are scores produced by the reviewing models during my work, rather than an independent measurement of defect rates.
One example involved deleting low-value tests. Muse made the deletions, while Opus reviewed their value and found that some removed guards protected against previous bugs. In another test change, Opus found three restored tests that could not fail. The review role asks a different question from the implementation role.
For T3 Code’s guest-sharing feature, I spent time reviewing the architecture and iterating on implementation. The feature lets a user share a thread by link, allowing a guest to view it and submit prompts with approval. Getting access boundaries right was difficult.

Sol-loop found three security problems: a guest could load an HTML visual after it had been rolled back; the browser could keep serving cached visuals after access was revoked; and a share closed between a session check and a read could still expose content in a race condition.
Another review concerned turns left running after unusual interruptions. Opus initially rated its own implementation five out of ten, then rated it nine after three review rounds. The reviewers found that a failed interruption could block a repair step and that an old snapshot could overwrite a running turn or a user’s steer.
This differs from asking a bot to inspect a pull-request diff after it is filed. The reviewing agents can use the computer on which the code was written, run and test the changes, ask the implementing agent questions and discuss what they find. They have the ability to validate as well as context to read.
Review against a person’s preferences
He asks reviewers to evaluate changes against a person’s likely preferences, including a Tailscale redesign prompted by Cory Quinn’s feedback. He had not yet sent the revised pull request to Quinn.
Review criteria can also be customized. I have asked agents to score how severe a problem is, how likely a change is to cause future trouble, and how likely I am to dislike it. This is a lossy way to steer agent work toward my preferences, but multiple models can catch different mismatches.
I tried a related approach when changing Tailscale setup for Cory Quinn, who uses T3 Code with a complicated enterprise account. I built what I thought was a solution, showed it to him, and he said it was the opposite of what he wanted.
I gave the working agent a screenshot of his feedback and permission to discard the existing changes, including the whole pull request. I asked it to investigate his public writing if needed, redesign the work around what he would like, and bring council back in to review against that standard.
I set the target at 9.5 out of ten from every reviewer. The new pull request is up, but I have not yet sent it back to Quinn. My expectation that he will prefer it is therefore still a prediction, based on the agents’ feedback rather than his response.
Token costs and runaway review
Repeated reviews consume large amounts of model usage. Browne describes uncontrolled loops and says the workflow needs limits on rounds and scope.
The first catch is cost. I use Muse heavily inside council rather than in most of my everyday coding, yet I hit its weekly limit on a $200 plan every week, often within two or three days. These feedback loops consume a lot of tokens.

The second catch is runaway iteration. A few times, the coding agent could not make the reviewers agree and kept going for more than 50 loops. In one thread it launched over 600 subagents across at least 20 review rounds, without making useful progress.
That same change grew from roughly 1,000 lines to more than 20,000 as the agent tried to satisfy every edge case. Each expansion creates more code for the next review and more opportunities to find small issues. I want a maximum number of runs and an instruction to stop when progress stalls, while fighting scope creep.
I have found Opus generally willing to stop and tell me when a loop is going nowhere, while in my experience Sol may continue pursuing small issues until the pull request becomes too large. I am also trying a lower reasoning setting to see whether a less exhaustive review works better.
I would not use this version of the workflow when paying full API prices for every token. Stacked subscriptions make it more practical for me, but the token burn is substantial and should be part of the decision.
Bring the human back when work is ready
He aims for agents to verify code before requesting human attention. He argues that watching every intermediate trace can lead to unnecessary interventions.
The goal behind these skills is to make the agent do everything it can to produce a verified, merge-ready change before it interrupts me. I do not want to watch every thread run unless I am debugging the interface itself.
I recently watched an Opus reasoning trace while working on the T3 Code thread view. It appeared to be heading in an obviously wrong direction, so I sent a correction. Just as I sent it, the agent produced the result I wanted; my intervention then confused it because it had already done the requested thing.
That experience reinforced my preference to leave a thread alone until it needs me. The agent should have the tools and resources to test its own work before a pull request returns for review. I estimate that roughly 80% of the pull requests I open from these threads are ready for me to merge immediately.
Even if council raises the chance of a ready-to-merge change by only a few percentage points, I find the token cost worthwhile in my circumstances. Others do not need to adopt my specific skills or tools; the goal is a workflow that brings back working code with fewer interruptions.
I have put the skills in a public repository and want feedback on where they work, how much usage they consume and where they fail. The way people work with agents is changing quickly, and my own preferences are not enough to establish what will work for everyone.
Mehr aus diesem Kanal
42:19EN
19:39EN
29:37EN
48:20EN
45:21EN
42:14EN