Manager (Claude Opus 4.5): Global event loop that wakes up specific agents based on folder (Kanban) state.

Product Owner (Claude Opus 4.5): Strategy. Cuts scope creep

Scrum Master (Opus 4.5): Prioritizes backlog and assigns tickets to technical agents.

Architect (Sonnet 4.5): Design only. Writes specs/interfaces, never implementation.

Archaeologist (Grok-Free): Lazy-loaded. Only reads legacy Java decompilation when Architect hits a doc gap.

CAB (Opus 4.5): The Bouncer. Rejects features at Design phase (Gate 1) and Code phase (Gate 2).

Dev Pair (Sonnet 4.5 + Haiku 4.5): AD-TDD loop. Junior (Haiku) writes failing NUnit tests; Senior (Sonnet) fixes them.

Librarian (Gemini 2.5): Maintains "As-Built" docs and triggers sprint retrospectives.

You might ask yourself the question “isn’t this extremely unnecessary?” and the answer is most likely _yes_. But I never had this much fun watching AI agents at work (especially when CAB rejects implementations). This was an early version of the process that the AI agents are following (I didn’t update it since it was only for me anyway): https://imgur.com/a/rdEBU5I

I can see this approach being useful once the foundation is more robust, has better common sense, knows when to push back when requirements conflict or are underspecified. But with current models I can only see this approach as exacerbating the problem; coding agents solution is almost always "more code", not less. Makes for a nice demo, but I can't imagine this would build anything that wouldn't have huge operational problems and 10x-100x more code than necessary.

Hard to keep up with all the changes and it would be nice to see a high level view of what people are using and how that might be shifting over time.

They couldn't even be bothered to write the Tweet themselves...

Some would argue there’s no point reviewing the code, just test the implementation and if it works, it works.

I still am kind of nervous doing this in critical projects.

Anyone just YOLO code for projects that’s not meant to be one time, but fully intend to have to be supported for a long time? What are learnings after 3-6 months of supporting in production?

Even 90 word tweets are now too long for these people to write without using AI, apparently.

Agents are stateless functions with a limited heap (context window) that degrades in quality as it fills. Once you see it that way, the whole swarm paradigm is just function scoping and memory management cosplaying as an org chart:

Agent = function

Role = scope constraints

Context window = local memory

Shared state file = global state

Orchestration = control flow

The solution isn't assigning human-like roles to stateless functions. It's shared state (a markdown file) and clear constraints.

This thread seems surreal, I see multiple flow repositories mentioned with 10k+ stars. Comprehensive doc. genAI image as a logo.

Can anyone show me one product these things have accomplished please ?

I used some frontier LLM yesterday to see if it could finally produce simple cascading style sheet fix. After a few dozens attempts and steering, a couple of hours and half a million token wasted it couldn't. So I fixed the issue myself and I went to bed.

But seems we are heading this way, from initially:

- a Senior Dev pairing with Junior Dev (2024/25)

- a tech lead/architect in charge of several Developers (2025)

- a Product Owner delegating to development teams (2026?)

---

- https://github.com/steveyegge/gastown

- https://steve-yegge.medium.com/welcome-to-gas-town-4f25ee16d...

I've been using that and it's excellent

---

function i8() {

if (Yz(process.env.CLAUDE_CODE_AGENT_SWARMS)) return !1;

return xK("tengu_brass_pebble", !1);

}

---

So, after patch

function i8(){return!0}

---

The tengu_brass_pebble flag is server-side controlled based on the particulars of your account, such as tier. If you have the right subscription, the features may already be available.

The CLAUDE_CODE_AGENT_SWARMS environment variable only works as an opt-out, not an opt-in.

The rate at which a person running these tools can review and comprehend the output properly is basically reached with just a single thread with a human in the loop.

Which implies that this is not intended to be used in a setting where people will be reading the code.

Does that... Actually work for anyone? My experience so far with AI tools would have me believe that it's a terrible idea.

This will only compound wasted time on Claude.ai, which exploits that time to train its own models.

Why time wasted? Claude’s accuracy for shell, Bash, regex, Perl, text manipulation/scripting/processing, and system-level code is effectively negligible (~5%). Such code is scarce in public repositories. For swarms or agents to function, accuracy must exceed 96%. At 5%, it is unusable.

We do also use Claude.ai and we believe it is useful, but strictly for trivial, typing-level tasks. Anything beyond that, at this current point, is a liability.

https://github.com/ruvnet/claude-flow

My implementation was slightly different as there is no shared state between tasks, and I don't run them concurrently/coordinate. Will be interesting to see if this latter part does work because I tried similar patterns and it didn't work. Main issue, as with human devs, was structuring work.

“FTSChunkManager agent is still running but making good progress, let’s wait a bit more for it to complete” (it’s implementing hybrid search) plus a bunch of stack traces and json output.

Mine also rotate between Claude or Z.ai accounts as they ran out of credits

In his second post he included a link to GitHub: https://github.com/mikekelly/claude-sneakpeek