@interjc: Over the past few days, I used my own subagent-team skill to lead an "AI team" in development — burning through the weekly quotas of several Claude/Codex/Gemini accounts plus hundreds of dollars in API costs on a major overhaul of a monorepo project. I pulled out all the delegation records and did a retrospective:

X AI KOLs Following News

Summary

The author shares a retrospective of using their own subagent-team skill to lead a Claude/Codex/etc. AI team through a major monorepo overhaul: cross-vendor model reviews offer the best ROI, rework volume depends on task risk rather than model tier, and they summarize a division of labor where low-tier models act as coordinators, strong models handle risky implementation, and top-tier models handle reviews.

Over the past few days, I used my own subagent-team skill to lead an "AI team" in development I burned through the weekly quotas of several Claude/Codex/Gemini accounts plus hundreds of dollars in API costs on a major overhaul of a monorepo project I pulled out all the delegation records and did a retrospective: The main agent was Claude Code, the driver was Opus 5.5 High, and the downstream tools were codex / agy and opencode (connected to the Claude API and a codex account) Over 300 internal subagents and over 200 external agent tasks (Codex, agy, OpenCode) The project is no small thing: two mobile apps and around eight Cloudflare Workers services. We did SDK upgrades, consolidated authentication, prepaid credits billing, an AI gateway, and an interface redesign. The main session had Opus 5.5 acting as director, responsible for task breakdown, writing contracts, acceptance, and commits — everything else was delegated out The most surprising finding: the most cost-effective use of external agents isn't writing code, it's reviewing. I had Codex's gpt-6.1-sol with high effort do read-only reviews of billing and auth code, and all 7 times it found real issues: charging a fee without returning results, double-charging, and reading other people's data via an internal token. Having a model from a different vendor look at the code fills in exactly the blind spots of your own model. Internal reviews were also worthwhile: out of 72 reviews, 21 raised blocking issues, nearly all confirmed by the implementer, with only 1 false positive The second finding: the amount of rework depends on task risk, not model tier. Code written by Opus and Sonnet both required rework after review at a 67% rate. Whenever money, auth, or table schemas are involved, no matter who wrote it, it has to go through several rounds of review — so rather than switching to a more expensive model, it's better to build review rounds into the schedule from the start Higher effort isn't always better either: Opus at xhigh took a median of 19 minutes per task at $3.70–11.50, and reviews still caught the issues that needed fixing every time; Sonnet at medium for small, clear changes took about a minute, costing anywhere from a few cents to a little over a dollar There's also an easily overlooked role: the "coordinator." Every external task was paired with a Haiku low subagent responsible for dispatching work, waiting for results, running acceptance checks, and verifying the scope of changes — the vast majority completed successfully External agents often can't run tests due to sandbox restrictions, so this layer is what actually does the real gating. Every external task failure was environmental (effort settings getting reset, sandbox denials, timeouts) — none of them modified files outside the intended scope, and not a single result needed to be thrown out and redone To summarize my division of labor: Low-tier models as coordinators; Mid-tier models for well-defined small changes and research; Strong models for risky implementation; Top-tier models and strong models from another vendor for reviews;
Original Article
View Cached Full Text

Cached at: 11/03/26, 08:23 AM

Over the past few days, I’ve been running an “AI team” for development using a subagent-team skill I wrote myself.

I burned through weekly quotas on several Claude/Codex/Gemini accounts and several hundred dollars of API spend, doing a major overhaul of a monorepo project.

I pulled out all the delegation logs and did a retrospective:

The main agent is Claude Code, driven by Opus 5.5 High, with downstream tools codex / agy and opencode (wired up to the Claude API and secondary codex accounts).

Over 300 internal subagents, over 200 external agent tasks (Codex, agy, OpenCode).

The project isn’t small: two mobile apps plus around eight Cloudflare Workers services, covering SDK upgrades, consolidating auth, prepaid credit billing, an AI gateway, and a UI redesign. The main session was Opus 5.5 acting as the director, responsible for breaking down tasks, writing contracts, acceptance, and commits — everything else was delegated.

The most surprising finding: the most cost-effective use of external agents isn’t writing code, it’s review. I had Codex’s gpt-6.1-sol on high doing read-only reviews of billing and auth code — all 7 runs found real issues: charging a fee without returning results, double-charging, and reading other people’s data via internal tokens. Running a model from a different vendor is a good way to cover your own model’s blind spots. Internal reviews were also worth it: out of 72 runs, 21 raised blocking issues, nearly all confirmed by the implementer, with only 1 false positive.

The second finding: how much rework you need depends on task risk, not model tier. Code written by both Opus and Sonnet needed rework at the same 67% rate after review. Anything touching money, auth, or table schemas will need several review rounds no matter who writes it — so rather than upgrading to a more expensive model, it’s better to budget review rounds into the schedule from the start.

Effort isn’t a case of higher being always better: Opus with xhigh had a median of 19 minutes per task at $3.7–11.5, and reviews still caught the issues that needed fixing every time. Sonnet at medium for small, well-specified changes took about a minute and cost anywhere from a few cents to just over a dollar.

Another easily overlooked role is the “coordinator”: every external task was paired with a Haiku low subagent responsible for dispatching work, waiting for results, running acceptance checks, and verifying the scope of changes — the vast majority completed smoothly.

External agents often can’t run tests because of sandbox restrictions, and this layer is where the real gatekeeping happens. The few failures on external tasks were all environment-related (effort settings being reset, sandbox denials, timeouts) — not a single one modified files outside the intended scope, and not a single result needed to be thrown out and redone.

To sum up my division of labor:

  • Low-tier models as coordinators;
  • Mid-tier models for clearly-specified small changes and research;
  • Strong models for risky implementation;
  • Top-tier models and a strong model from another vendor for review;

Similar Articles

@yibie: Recommend this project. shadcn (creator of shadcn/ui) built an Agent Skill — let the most expensive model handle auditing and planning, and let the cheap model write code. The idea itself isn't new, but shadcn turned it into an installable, orchestrated system with an execution closed loop. Every design decision is practical...

X AI KOLs Timeline

shadcn released the Agent Skill project improve, which has high-cost models perform code auditing and planning while low-cost models execute, forming an installable, orchestrated system with an execution closed loop.

@vintcessun: It turns out that having multiple AI agents work together as a team is better than a single general-purpose agent in this way: each role is bound to its best model, memory and skills accumulate across conversations. Instead of taking turns, a task is handed off with a brief handover note. Runs locally, all file states are in ~/.crew44, free MIT license.

X AI KOLs Timeline

Crew44 is a local-first orchestrator that turns coding agents like Claude Code and Codex into a coordinated team of specialists, each bound to its best model, with persistent memory and skill accumulation across sessions. It runs entirely on your machine with no cloud dependence and is free under MIT license.

@indigox: How agents split up work is being taken back by model providers! Anthropic just launched dynamic workflows, letting Claude write its own plans and decide who executes, who grades, who critiques — developers only need to supply the task and a budget. What surprised me most is a set of data: under the same bud…

X AI KOLs Timeline

Dynamic workflows, shared by Anthropic at Vercel Ship 2026, let Claude autonomously write plans and assign roles like executor, evaluator, and critic. Data shows that adding session memory replay to conversations boosts the perfect-score task rate from 21% to 71%, highlighting that memory accumulation is becoming the new battleground for competitive moats.

@justloveabit: 100 ready-to-use sub-agents that upgrade Claude Code from an 'assistant' to a 'complete AI company'. Most people still use Claude Code for single-agent chat. The real experts are already using 100+ specialized sub-agents to build their own AI engineering teams. Awesome repo...

X AI KOLs Timeline

Introduces an Awesome repository containing over 100 sub-agents that upgrade Claude Code from a single-agent assistant to a multi-agent collaborative AI development platform, and provides a quick-start guide and top sub-agent recommendations.

@justloveabit: With This Open-Source Tool, I Got a Team of AIs to Work for Me. Here's the deal: I've been tinkering with various AI agents lately. Multiple Claude Code windows open, Codex running, occasionally using Cursor. The result? Total chaos—I had no idea what each agent was doing or how much it was costing. Restar…

X AI KOLs Timeline

This article introduces Paperclip, an open-source tool designed to centrally manage and orchestrate multiple AI agents. By simulating a corporate organizational structure, task assignment, and budget control, it addresses key pain points in multi-agent collaboration, such as lost context, unpredictable costs, and chaotic scheduling.