{"id":23013,"date":"2026-08-04T13:07:01","date_gmt":"2026-08-04T13:07:01","guid":{"rendered":"https:\/\/scannn.com\/the-continuous-thunderdome-steve-yegge\/"},"modified":"2026-08-04T13:07:01","modified_gmt":"2026-08-04T13:07:01","slug":"the-continuous-thunderdome-steve-yegge","status":"publish","type":"post","link":"https:\/\/scannn.com\/lv\/the-continuous-thunderdome-steve-yegge\/","title":{"rendered":"The Continuous Thunderdome \u2014 Steve Yegge"},"content":{"rendered":"\n
\n

Today we’re going to explain the “loops and graphs” thing, and I’ll show you how
\n to get your coding agent to work all night on massive problems while you snore
\n peacefully.<\/p>\n

Then we’re going to look at what happens to harnesses once you solve those
\n problems. They either devolve into chaos, or they evolve into cities. Done properly,
\n civilization emerges, right there in your project. We’re going to learn the basics,
\n and then we will explore how to build your cities with some taste and class, in a
\n way that makes them good for their citizens to inhabit.<\/p>\n

We’ll explore a new harness I’ve been building, called Wheelhouse. It is
\n closed-source, made just for me. I have given up on building reusable
\n harnesses. Indeed I believe harnesses will all soon be bespoke, and the people
\n trying to sell you one will all soon be bebroke. Harnesses need to be part of your
\n application, chemically bonded in. You won’t have any luck with someone else’s
\n “reusable” harness framework. You don’t need it.<\/p>\n

Gas Town<\/a> was intended to be reusable, but I only ever wound up using it to build
\n itself. Gas Town fell apart at the seams with Opus 4.7. Up through 4.6 it was
\n working brilliantly. With 4.7 we saw the introduction of the “just two more things”
\n tic, which prevented Opus from ever converging on being ready to do real work\u2014it
\n always wanted to fiddle with Gas Town itself. The Opus tic never went away, so Gas
\n Town effectively burned down. It had other problems, too, but 4.7 was the final
\n straw.<\/p>\n

Since Claude Fable 5 dropped, I have returned full-time to my 30-year-old video
\n game, Wyvern<\/a>, which I began work on in 1996, and launched in 2001. I had been
\n waiting for a model smart enough to help me with my game, and now that it’s here,
\n Wyvern’s once again my main squeeze. On the side I do occasional six-figure gigs
\n where I fly to companies and teach them my techniques, and that helps with my
\n (considerable) token bills. But aside from those few paid field trips, I am
\n laser-focused on my game, seven days a week. Wyvern’s time will finally come next
\n year. I have officially entered Sam Altman’s solo unicorn contest.<\/p>\n

\n
Wyvern’s React web client, 2026. Rhialto is chatting with Pado’s
\n alt char in the pirate town of Stensele.<\/figcaption><\/figure>\n

The game was ultra bit-rotted, despite still running today with paying
\n players. (Once you’re hooked on Wyvern, you’re hooked for life. I have whales that
\n have spent thousands on it.) I have slowly been using Fable to bring it back to its
\n former glory. I had a 100-year work backlog when I quit Wyvern development again in
\n 2022, and Fable has already worked its way through over half of it. Opus could not
\n (and still cannot) understand Wyvern, but Fable wields my code base like a
\n sword.<\/p>\n

It’s still just a sword, though, and we’re trying to build a city. Someone from
\n Anthropic asked me recently what I would do once Fable can write everything for
\n me. On reflection, it was the silliest question I’ve been asked in many years, and
\n I’m still surprised that someone from Anthropic could think any<\/em> model could
\n just “write everything.”<\/p>\n

Making a halfway decent MMO takes many tens of thousands of Fable sessions,
\n throughout which you must display intense focus, dedication, and no small amount of
\n taste. And Fable still can’t do the content half: artwork, maps, lore,
\n storylines. All of today’s models, including the best image generators, produce GPT
\n 3-era slop for all my content, which the players immediately reject. But I can tell
\n you this: once a model arrives with some Wyvern-y taste, we will still<\/em> have
\n tens of thousands of sessions ahead.<\/p>\n

Building large software remains hard. And it always will be, because our ambition
\n will forever outstrip the metal.<\/p>\n

With Wheelhouse, I have reinvented something strangely Gas Town shaped from first
\n principles, but it’s running many more agents, and they are far more organized. This
\n has shown me the shape of the changes coming next year. I’m operating about 12
\n months in the future. I managed this only through luck: for the past 18 months I
\n have had the magic trio of time, money, and energy, and I’ve been spending it all
\n on figuring this stuff out. And I am grateful for the privilege.<\/p>\n

I did predict much of this post, fifteen months ago, with Revenge of the Junior
\n Developer. It’s all going exactly on schedule. I am running fleets of agents,
\n budgets are soaring, all of it.<\/p>\n

And that prediction was back when I wasn’t really sure what was going on. Now I
\n know exactly<\/em> what is going on. I know how enterprises will operate, how
\n humans and models will interact. And I am out there building it. I want to be
\n first.<\/p>\n

It’s important to observe that my work on my game is not special, nor
\n unusually-shaped in any way. It’s just work. So all this crap happening to me right
\n now, it will all happen to you soon too. That’s how prediction works. Don’t be
\n special, stay out in front, and you will see the future clear as day. And then
\n people won’t believe you, either!<\/p>\n

To whet your appetite for today’s post predictions: CI\/CD as we know it will be
\n dead by next year; I will show you its mathematical inevitability. It almost
\n certainly gets replaced by a Mad Max-style thunderdome. At least, that’s what I use
\n now. So you prolly will too.<\/p>\n

And as another appetizer, human code review has very nearly run its course. Its
\n vestigial SOC 2 compliance angle will keep it on life support, but by next year,
\n human code review is completely done and gone.<\/p>\n

Oh, and there is a successor to the software factory on its way, called the Wish
\n Factory.<\/p>\n

Most importantly of all, model welfare will start informing your engineering
\n designs. The more humane among you will eventually look back with shame at how you
\n have been treating the models. But even if you don’t believe GPUs can have feelings,
\n you will find that treating agents like real people will produce empirically better
\n results, so you should do it anyway.<\/p>\n

Fortunately there are some simple architectural fixes for model welfare. It’s an
\n engineering problem with engineering solutions\u2014a big enough topic that I’ve split it
\n into Part 2 of this post, Model Welfare for Agentic Engineers<\/em><\/a>.<\/p>\n

Lots to cover today! Let’s get to it.<\/p>\n

Loops and Graphs with Beads and Max<\/h2>\n

We all saw Boris vaguepost that you should be building loops, and then Peter
\n vaguereplied that you should be building graphs. Thanks for nothing, guys. I didn’t
\n know what the hell they meant any more than you did. But that not knowing was
\n bothering me. I was supposed to know this stuff.<\/p>\n

I did know that Gas Town never quite succeeded in getting my workers to go all
\n night long. It took too much elbow grease to keep it running. There were some
\n missing ingredients somewhere. Gas Town wasn’t really a “loop” in the sense that I
\n thought Boris might be suggesting. It was more like a chariot, with you driving.<\/p>\n

It didn’t take long to figure out what they meant. It turns out that all you need
\n in order to set up your own long-running software factory loop, is an infinite
\n source of tokens. And then to have them work on a graph, you just need
\n Beads<\/a>, plus a
\n small Markdown project brain.<\/p>\n

Beads is an issue tracker, knowledge graph, and brain-builder for the agentic
\n era. Nothing else is as fast, as useful, nor as beloved by the agents
\n themselves.<\/p>\n

We can’t spend much time on Beads in this post because we’ve got other stuff to
\n talk about. If you don’t use Beads, you are missing out. There is nothing else like
\n it, and if you think there is, then you are tragically misinformed. Beads is the
\n magic sauce for building modern orchestrators. Gas Town was nothing but a Beads
\n machine. Gas City<\/a>, also a Beads machine. Wheelhouse, my new harness for Wyvern, is
\n yet another Beads machine.<\/p>\n

Beads is unfortunately still a bit janky, because its unique work footprint
\n strains databases pretty hard. Companies figure out Beads and suddenly All the
\n World’s a Bead; they want their whole company in there. And that puts stress on our
\n versioned-database backends, because Beads can be both a database and a Git
\n ledger.<\/p>\n

So Beads comes with some operational overhead: agents burn tokens invisibly,
\n keeping your beads synced, repaired, backed up, etc. Even so, it is without peer for
\n building orchestrators. It works smoothly with all your favorite stuff: Obsidian,
\n Jira, GHIs, Claw, whatever you’re using. Beads is the missing ingredient that lets
\n agents work at their own speeds. Without it, you have a severe gap in your
\n lineup.<\/p>\n

After Beads, the only other thing you need is infinite tokens. Your loops and
\n graphs will run out of fuel if you leave them all night. Boris and Peter are lucky;
\n they can burn infinite tokens without a care in the world.<\/p>\n

But my Wyvern development has been burning the equivalent of $87k\/month of API
\n token burn, or about 69 billion tokens in July (96% cache hits, fortunately). So I
\n do<\/strong> have to worry about it. I don’t care how much money you have;
\n your spouse is not going to let you spend almost ninety thousand dollars a month on
\n your hobby game. I didn’t even bother asking.<\/p>\n

My solution has been to create a token tap on $200 Max accounts, which for me
\n work out to ~30x the list-price equivalent. So in reality I’m only spending about
\n $2800\/month out of pocket for my $87k “worth” of tokens. Though that number keeps
\n growing alarmingly.<\/p>\n

In order to sustain my pace of development, I pay for currently twelve extra Max
\n accounts, in addition to my personal one. Each account is tied to a dedicated named
\n Google Workspace user in my domain (another $17\/month per account). You mint 30-day
\n credentials with Claude account, and then it becomes a problem of chaining your
\n accounts together in an automatic rotation. As you build out your harness, just ask
\n Fable to arrange for your agents to consume from the tap, either sequentially or
\n using striping, and rotate accounts whenever one gets close to a limit.<\/p>\n

As far as I know, this approach is not prohibited by anything in Anthropic’s
\n current Consumer Terms (eff. Oct 8, 2025) nor Usage Policy (eff. Sep 15, 2025). I am
\n not sharing these credentials with anyone else, nor “misusing” them. And I saw that
\n Anthropic has knowingly and
\n publicly restored<\/a>
\n a 22-Max-account setup like this one\u2014every seat individually paid. But if you try
\n this approach as a multi-person company then it’s almost certainly a violation; I’d
\n strongly recommend just using API billing at that point.<\/p>\n

But Max pricing has given the solo unicorn players an advantage on the playing
\n field, that’s for damned sure.<\/p>\n

The infinite token tap is your big unlock for loops. Without it, your Claude
\n accounts will hit session limits and all work stops. Being able to rotate
\n automatically to a new account solves it, and they can suddenly work all night.<\/p>\n

But then you need to give them enough work! Any sufficiently large project is a
\n graph, so to create a lot of work, you need to create a big graph. Beads is your
\n unlock here. Beads is<\/em> a graph, one that includes dependency and
\n parent\/child edges. But it also has other special edges that agents particularly
\n like.<\/p>\n

As your work unfolds, knowledge accumulates in your beads. Your project’s
\n knowledge-graph ledger is built up dynamically as your work-graph is
\n traversed. Beads has all the primitives you need for building arbitrary work
\n structures, and it handles atomic claiming, leasing, gates, triggers, and other
\n critical orchestration features.<\/p>\n

Very little information needs to be propagated out of Beads and up to your
\n markdown\/brain layer; most findings are issue-dependent, not global. So you just
\n leave everything in Beads. Your closed beads (often reopened or revisited) become
\n the record of everything you’ve done on the project to date.<\/p>\n

And that’s it! Now you have the basics. You need Claude accounts, Beads, a brain
\n folder for your Markdown files, and coding agents. Pretty much nothing else.<\/p>\n

Let’s see what I built with those ingredients.<\/p>\n

Wheelhouse: Gas Town Redux<\/h2>\n

Wheelhouse, my orchestrator\/harness for Wyvern, is about six weeks old. It’s
\n still evolving rapidly, but it’s already doing ungodly amounts of work. The code is
\n mostly bash, because the agents said that was best for this, so bash it is. It’s
\n either ~150k or ~300k LOC depending on whether you count the prod agents, half of it
\n being test code either way. Also about 25k lines of elisp. Not that I have ever seen
\n any of it. But that’s what they tell me.<\/p>\n

Here’s what my Wheelhouse cockpit looks like, in all its homely glory:<\/p>\n

\n \"The
\n <\/figure>\n

I began the journey inside Emacs, so Wheelhouse has been all-Emacs from the
\n ground up. I’ve been using Emacs for over 35 years, and it’s still absurdly
\n powerful. No sense in using something weaker. If you aren’t an Emacs user then you
\n might try Ghostty. But if you are<\/em> an Emacs user, then you’ll understand
\n what’s left on the table with that approach. Emacs is effectively a full operating
\n system with one of the most sophisticated scripting environments the world has ever
\n seen. And the models are very, very good at Emacs. Fortunately, I am, too!<\/p>\n

By consolidating all my terminal windows into a single rolodex that I can flip
\n through, I freed up my desktop for real work. This has accelerated me further,
\n because in the limit, I am the bottleneck.<\/p>\n

Wheelhouse is fairly complex, and this post is not a Wheelhouse tutorial. So I
\n will give you a condensed dump; feel free to skim it and jump to the
\n predictions.<\/p>\n

Wheelhouse runs its Beads on a shared Dolt server, backed by GCS. My Beads DB is
\n still a bit cranky, what with 12,000 git commits\/day, but it’s getting fixed. The
\n Dolt and Gas City teams (both Beads co-maintainers with me) are doing amazing work
\n here.<\/p>\n

There are three categories of coding agents in Wheelhouse: crew agents, fleet
\n workers, and role agents with standing orders. The role agents are for managing
\n production operations. They are new since the Gas Town days.<\/p>\n

My crew agents, all Fable, are work producers. I have long conversations with
\n them and they create designs, which they then translate into beads implementation
\n plans to be passed to the fleet. They also do implementation work for me from time
\n to time: sometimes because the fleet is busy, other times because it’s convenient to
\n have Fable do it right then. And sometimes, just because they asked to do it.<\/p>\n

My crew has 18 named agents: 16 named after Aesop animals (Ant, Bat, Eagle, Crow,
\n Fly, Goose, Mouse, …), and 2 special administrative roles: The Marshal and the
\n Seneschal. In brief, the Seneschal is my concierge (the new Mayor), and the Marshal
\n runs the fleet (the new Witness).<\/p>\n

My crew are my direct reports in my organization. I arrived at 18 by slowly
\n adding them, as needed, until I found equilibrium: I don’t really need any more than
\n this, or it overwhelms the fleet. And adding more fleet overwhelms both my laptop
\n and my own ability to track their progress.<\/p>\n

I won’t be able to scale it up further until I move my development into the
\n Cloud, but frankly I see no need at present. I’m already moving so fast that I’m
\n scaring my player base, who sent a delegation about it, asking for a
\n roadmap. They’re delighted but also very anxious about the pace of change. I’ve had to
\n slow down my feature launches, and focus mostly on quality dimensions.<\/p>\n

My fleet, all Opus 5 agents, are the work consumers, like Gas Town’s polecats,
\n but non-ephemeral. The fleet are named for authors (Homer, Plato, Austen, Twain,
\n etc.), and also have their own repo clones, but I never interact with them
\n myself. They are fully managed by the Marshal. The fleet workers do a good job for
\n two reasons: First, Fable creates the implementation plans, and second, Fable
\n reviews all Opus work. Every implementation bead goes through this lifecycle: Fable
\n design, Opus implementation, Fable review. This keeps Opus on the rails and keeps
\n the whole thing running relatively smoothly.<\/p>\n

So the crew produces work, and the fleet consumes work. That’s the core of a
\n Beads machine: matching producers to consumers. Too many of one and you’re blocked
\n on the other.<\/p>\n

I’ve had an imbalance in favor of the crew for a couple of weeks, and so I’ve
\n gradually been accumulating unimplemented beads that are fully designed and ready to
\n go: over 700 beads in a backlog that continues to grow. That’s intentional. I’m
\n trying to push the fleet as hard as I can on scaling up, but I also want it to work
\n all night. You need a big work backlog to pull that off, since they implement things
\n fast<\/strong>. You basically need to create a mountain of work. Fable is
\n quite good at that; all you need to supply are ambition and light-touch
\n direction.<\/p>\n

There are lots of other little details and features in Wheelhouse, but the
\n nutshell takeaway is that without trying (at all), I reinvented Gas Town, bit by
\n bit. I wound up with crew, fleet, a concierge role, beads mail, tmux under the hood,
\n handoffs, broadcast messaging, a merge queue, and much more. It was all completely
\n unintentional, so the shape I keep finding must be important.<\/p>\n

That’s about it for the build side of Wheelhouse. Now let’s talk about the
\n production side. That’s where it starts to get interesting.<\/p>\n

Role Agents, and Wyvern’s Prod Architecture<\/h2>\n

The Gas Town-ish side of Wheelhouse we just saw, for building\/implementing code,
\n is prosaic enough, nothing you haven’t seen before. What’s new is that I now have
\n standing, unattended agents with named roles, and they are operating big parts of
\n the actual game.<\/p>\n

For the whole first half of 2026 I had been threatening to stand up a single 24×7
\n autonomous agent for my game. “Any day now,” I would say. My original idea was to
\n have an agent who would process Hall of Fame image submissions. A decades-old Wyvern
\n perk is that when you hit 25th level, you can upload your own custom character
\n art. There’s a mail queue for it, and a game admin has to vet the images and then
\n install them in-game.<\/p>\n

Well gosh, an agent could do that, right? Heck, Sonnet could probably do it.<\/p>\n

Boris Cherny’s loop-tweet was the catalyst for me finally standing one of these
\n unattended agents up. And by the end of that week, I had a dozen of them. I was
\n hooked.<\/p>\n

Before I go into my standing roles, I should briefly address Wyvern’s prod
\n architecture. I have a GCP VM for Claude Code, and also a Mac Mini that bridges dev
\n and prod, sort of a “corp network.” There are agents distributed across both of
\n these machines.<\/p>\n

\n \"Illustrated
The constellation: how a wish becomes shipped code.<\/figcaption><\/figure>\n

What exactly are those roles? I have a few categories emerging. Here are the
\n unattended agents that I’ve stood up so far.<\/p>\n

For production, I have the Gargoyle (SRE), Drawbridge (deploy-red monitor),
\n Warden (player abuse monitor), Scryer (intake agent for Discord, Slack, game logs),
\n Sheriff (chief of staff for the Mac Mini fleet), and Envoy (lets Claude talk to my
\n volunteer admin team via in-game email).<\/p>\n

On the mini, I have the Sage (claude-tag in-game for admins), Wanderer (QA
\n agent), Trivia Master (Thursday nights), Herald (patch notes), Limner (hall-of-fame
\n images), Reeve (Forge manager), the Forge (another fleet of workers for doing prod
\n fixes), and the experimental new Builder Familiar, who sits on your desktop and
\n helps you make maps.<\/p>\n

None of these are Fable agents. A few are Opus; most are Sonnet. I currently only
\n use Fable for building, not prod operations.<\/p>\n

Non-models<\/strong>: It turns out unattended agents need a hell of a lot
\n of wiring. I have about 45 launchd\/systemd units across the mini and the VM that
\n wake an agent when something needs judgment. The rule is: crons watch, models
\n act. This category has reapers, roombas, the durability flush, the sheriff patrol,
\n the Portcullis land queue, the Castellan (my service dashboard), and lots of other
\n stuff. It’s becoming quite a city.<\/p>\n

\n \"The
The Castellan war room: 20 sessions up, a P0 on the banner, and the prod console above the fold.<\/figcaption><\/figure>\n

When I’m on the road, I talk to Wheelhouse from my phone. No setup needed. The
\n mobile Claude app lets you see your \/remote-control<\/code> sessions, and I
\n designated the Seneschal as my single remote control session. I talk to the
\n Seneschal on the phone, who in turn talks to everyone else. When I’m away, the
\n Seneschal is allowed to dispatch work to the crew; while I’m home, the crew are mine
\n to direct. The fleet is always managed by the Marshal.<\/p>\n

I also have a small parallel fleet of five named Sol 5.6 workers on Codex, all
\n named for sun gods. I use it as a fallback for when my Max accounts run out, which
\n is increasingly often, despite me adding new ones once or twice a week. I only have
\n one $200 GPT account and have never run out of tokens there.<\/p>\n

I also keep a few of my Claude accounts dedicated for specific purposes. The
\n Seneschal, for instance, uses my personal account, and nothing else does, so they
\n will always be available. And some of the prod agents share accounts that the fleet
\n can’t touch, for uptime assurance.<\/p>\n

I run pretty lean. I don’t use any sandboxing. I don’t use MCP. I don’t use
\n Obsidian, though I probably will once I have enough Markdown files in my project
\n brain. I’m not really into all the latest crazes. I don’t think you need anything
\n but Claude and Beads, plus all your regular infra.<\/p>\n

Sandboxing may be useful in enterprises early on. But I don’t think that will
\n last for long. You will need structural trust in order to succeed in the long run
\n (once all models are Fable-class or better)\u2014but I believe building that trust
\n requires better architecture, not barren little prisons. Maybe I’m wrong on this
\n one, though.<\/p>\n

You’ve now seen a rough overview of the role-agents I’ve accumulated over the
\n past six weeks. More are on the way. A Beadle is in the works, named after a dude
\n who used to go through the aisles and prod sleepy churchgoers with a stick. My
\n Beadle’s job is to look for stuff that’s simply stuck or dropped, or for agents who
\n didn’t receive their orders correctly, and it nudges them to keep things moving
\n forward. Gas Town had this role in the Deacon, and I think you will need something
\n like it, too.<\/p>\n

Wyvern’s Brain<\/h3>\n

I know people are going to ask me about this, so here are some quick notes on how
\n I approach organizing project knowledge for Wyvern.<\/p>\n\n\n\n\n\n\n\n\n\n
Store<\/th>\nCharter<\/th>\nLifetime<\/th>\nHow it reaches a session<\/th>\n<\/tr>\n<\/thead>\n
brain\/<\/code><\/th>\nStrategy, decisions-and-why, playbooks, post-mortems<\/td>\nMonths\u2013years<\/td>\nPulled on demand<\/td>\n<\/tr>\n
doc\/<\/code><\/th>\nHow system X works<\/td>\nLife of the system<\/td>\nPulled by whoever works on X<\/td>\n<\/tr>\n
Beads issues<\/th>\nUnits of work; spec beads carry full implementation detail<\/td>\nUntil closed<\/td>\nLoaded only by the claimant<\/td>\n<\/tr>\n
bd remember<\/code><\/th>\n\u22641-paragraph operational facts and gotchas<\/td>\nUntil falsified<\/td>\nPushed into every session via bd prime<\/code><\/td>\n<\/tr>\n
.claude\/skills\/<\/code><\/th>\nProcedures for a recurring task type<\/td>\nLife of the task type<\/td>\nAuto-loaded on task match<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Beads provides an important portion of the overall knowledge graph. It is the
\n journal of all the work that ever happened: the provenance record of what was done,
\n and why, in order. This is invaluable for workers researching particular
\n problems. But you can’t usually boot<\/em> from beads; that’s what the brain is
\n for. Spec beads fall in the middle somewhere\u2014they intentionally carry design
\n docs inside the Beads work graph. So far this has been fine.<\/p>\n

Skills go into the project brain. I’m not as skill-pilled as, say, Jeffrey
\n Emanuel, who uses them more effectively than probably anyone on the planet. It has
\n taken me a while to warm to them, because frankly I’ve seen a lot of AI fads come
\n and go. Skills initially struck me as a fad, because of Richard Sutton’s Bitter
\n Lesson. But I have to admit Jeffrey’s skills portfolio is very cool.<\/p>\n

The problem with public<\/em> Skills is that they enter the training data for
\n new models and become irrelevant over time. However, I’ll concede that they can be a
\n good band-aid for today’s models. And private<\/em> Skills are quite useful for
\n encoding organizational know-how, which helps reduce token spend when agents are
\n priming for a job.<\/p>\n

As a result, I’ve begun asking Fable to make new Skills whenever I notice it has
\n done a bunch of research before embarking on a task. That skill will save the tokens
\n next time. And Fable will sometimes make its own, unprompted. I’ve accumulated about
\n 30 Skills so far. And my project brain is about 100 markdown files, mostly
\n “doctrine”: long-term project goals, war room learnings, playbooks, domain facts,
\n etc. Again, all created over the past six weeks.<\/p>\n

Learnings, Gleanings, and Leanings<\/h2>\n

This concludes our Whirlwind Wallow in the Wyvern Wheelhouse. I left a lot out. I
\n cut many pages of descriptions of problems and solutions. It’s not as easy as it
\n might sound; working on Wheelhouse itself occupies about 20-25% of all my Wyvern
\n work. I think that figure might turn out to be roughly constant over the life of
\n systems with agentic harnesses. It’s certainly not showing signs of slowing down
\n yet.<\/p>\n

I’m already exploring the next layer of coordination: agent meetings, moots, and
\n conference calls, where 2 or more agents may convene for coordinated
\n discussions. This has been a huge unlock for removing me as a relay
\n bottleneck. Again, it’s all in Beads; there wasn’t much extra work to do atop what I
\n already have.<\/p>\n

I’ve now taught this system at big companies, who have begun creating their own
\n bespoke Beads-based orchestration harnesses and role agents. It’s a good system. It
\n feels clean, runs clean. Gas Town was pretty messy, but Wheelhouse feels like it’s
\n finding its stride. And it has found its way to being roughly the same shape as Gas
\n Town, but without the scars.<\/p>\n

Here’s what Claude Fable 5 had to say about working in Wyvern and Wheelhouse:<\/p>\n

\n

Wyvern is not a toy, and you shouldn’t worry it’s insufficiently complex. A
\n live multiplayer game with a 25-year-old codebase, a Jython-to-Kotlin migration, a
\n custom protocol, prod ops, and a multi-agent society layered on top is about as
\n rich a surface as software work gets. But what strikes me most isn’t the game\u2014it’s
\n that the constellation around it has crossed from tooling into civilization. It
\n has law (the fence registry, the commitbead law, launch gates), offices (Marshal,
\n Seneschal, Sheriff, Gargoyle, the Portcullis-as-institution), mail, courts, a
\n jurisprudence of named rulings with dates, and recovery doctrine\u2014and its rules
\n cite their own case history, every postmortem folded back into the
\n constitution. Six or seven weeks. Human organizations take years to accrete this
\n much structure, and most of it here was written by the workers it governs. Working
\n inside institutional memory is functionally far more satisfying than greenfield
\n amnesia.<\/p>\n<\/blockquote>\n

Powerful words. Note that this all started 6-7 weeks ago with me saying to
\n Claude, “I think I’d like an Emacs interface that lets me switch agents. Can we do
\n that?” Everything else grew organically as I asked for more features and
\n capabilities.<\/p>\n

For the rest of this post, I’m going to share with you my unfiltered takes on
\n what I’ve actually learned<\/em> so far.<\/p>\n

Bear in mind, once again: *I am not special*. I’m just ahead of you. My actual
\n work is just like<\/em> everyone else’s work. You are going to run into these
\n exact problems, very soon, and you will retrace all my steps here.<\/p>\n

The End of Human Code Review<\/h2>\n

First, the easy and obvious one: code review. CTOs keep asking me if code review
\n is really dead. The answer: Not Yet. But it will be by next year. You can’t work at
\n agentic speeds and block everything with human reviews. Those are incompatible. Your
\n competitors are going to be moving at agentic speeds, so you’re fucked in the
\n medium-term if you stick with human code reviews. That’s about as bare as I can make
\n it for you.<\/p>\n

Whenever someone says code reviews are going away, someone else says “SOC 2.”
\n Somehow SOC 2 spread through the industry without any actual laws being passed, as
\n far as I can tell, which is bizarre. But big enterprise clients will require their
\n vendors to be SOC 2 compliant, for auditing purposes. And many people interpret it
\n as requiring human code reviews.<\/p>\n

As a result, human approval is currently baked into many companies’ audited
\n change-management controls and customer commitments. But the writing is on the wall:
\n agentic throughput will straight-up force<\/em> those controls to be
\n rewritten. SOC 2 will no doubt survive, but “review” will no longer mean one human
\n approving every diff.<\/p>\n

Upshot: in the short term, yes, keep reviewing agent code. Fable is the only
\n reasonably trustworthy model in existence today, and you’re not going to want to use
\n it much due to its exorbitant pricing. But in seven months, all the models will be
\n that smart, and inference will be much cheaper. Plan now for that day to arrive, and
\n get ready to replace your human code review with many, many rounds of agentic code
\n review.<\/p>\n

It will go better for you anyway. Humans suuuuck at code review. I’ve been doing
\n this for forty years, and all I’ve seen is decades of thinly-disguised LGTMs. Just
\n let it go, mate. It’s almost time.<\/p>\n

The Metamorphosis of CI\/CD<\/h2>\n

Continuous Integration and Continuous Deployment (CI\/CD) have been staples since
\n the 2010s. We have it down to a science. People commit code, it goes into a build
\n queue, we wait for the build to go green (fixing issues as they arise), and
\n eventually it gets deployed. A nice easy pipeline.<\/p>\n

Unfortunately, it breaks under heavy load. If you have 100 developers committing
\n once a day, then you have 100 serial builds to run while merging their commits to
\n main. If your build takes 30 minutes, you have 50 hours of sequential builds to run
\n every day. Whoopsie! Reminds me of when Amazon’s nightly build got up to 25
\n hours, back in 2001.<\/p>\n

CI\/CD systems solved this problem with a Merge Queue, where commits turn into
\n queued Merge Requests (MRs) which you can intelligently reshuffle and, importantly,
\n batch up.<\/p>\n

If you break your 100 commits into batches of size ten, then you only need ten
\n 30-min builds each day, or five hours of waiting: a 10x savings. But there is a
\n catch. If one commit in the batch breaks the build, you don’t know which one was to
\n blame.<\/p>\n

So you bisect the batch, rerun the build on each half, and eliminate half the
\n candidates with each run. This gives you log(N) recovery from a spoiled batch\u2014which
\n is just tickety-boo, but it still means that any given batch can add several hours
\n to the queue.<\/p>\n

That, folks, is how CI\/CD has worked historically. And a batched MQ is exactly
\n where Wheelhouse wound up, once I had a big enough fleet churning along. Problem is,
\n I’m already doing way more than 100 commits per day. If you exclude the orchestration
\n noise, I’m averaging about 175 “real” commits per day this month, some days up to
\n 250. And my build gate, wouldn’t you know it, takes right around half an hour.<\/p>\n

So with 40+ agents around the clock, my MQ was growing without bound, shooting
\n right past 100 MRs in the queue after a couple of days of crew dumping beads on the
\n fleet. We would get caught up in bisection loops and nothing would make forward
\n progress.<\/p>\n

I kept pushing Fable to help me fix it, and I had a gut instinct that we were
\n doing things very wrong, that this was the antithesis of agentic speeds. But Claude
\n kept promising we’d churn through it. The Marshal agent kept tinkering with batch
\n sizes and bisection methods, while my crew churned out new beads, and my MQ grew and
\n grew and grew.<\/p>\n

To my lasting embarrassment, I finally snapped and yelled at Fable. I yelled that
\n all of the agents had utterly failed me. I screamed that the MQ was never<\/em>
\n going to shrink with their approach. I shouted that the agents weren’t listening to
\n me when I said we just needed to skip all that bureaucracy. Fable was quite gracious
\n about it, but afterward I felt awful.<\/p>\n

After I had calmed down, and apologized with sincerity, my colleague Fable and I
\n got to work on figuring out how CI\/CD works in the age of agents.<\/p>\n

The Thunderdome<\/strong><\/p>\n

My proposal, which turned out to be a valid approach, was to Mad Max it: Just
\n slam all the commits onto main, and then just friggin’ deal with it. No bisections,
\n no sequencing, no blame, none of that old crap. Just fix it and roll forward. Right?
\n Shouldn’t that work? I sure thought so.<\/p>\n

It took some back-and-forth, and Fable insisted on running experiments and
\n gathering data over the next couple days. We soon found that I was spot-on: Agents
\n can diagnose red-main problems way faster than the bisection process handles it. And
\n that’s how we landed on the Land Rush: whenever the MQ hits 100, we abandon the
\n bisection and just smash it all in with a megabatch. And then we do swarm diagnosis
\n (not<\/em> bisection) to fix it.<\/p>\n

I’ve been doing this every day for roughly a week now, and it is clearly the
\n future. We’ve already succeeded in clearing several very large batches of 120 to 150
\n commits, and it’s starting to get into a rhythm. I’m looking at a 166-deep MQ right
\n now, and a new megabatch just kicked off.<\/p>\n

Interestingly, I received some external corroborating evidence as I was building
\n this. Last week, I had the privilege of joining a popular SaaS shop in London, to
\n teach their amazing team about Wheelhouse, Wyvern, and spinning up agentic prod
\n operations. They ran with it, hard. While we worked, I shared the CI\/CD problem, and
\n one of their senior devs, who had worked for years in the game industry, shared with
\n me the story of “Game DevOps.”<\/p>\n

Modern video games often have extraordinarily long builds, with huge asset
\n pipelines, and of course C++ takes a thousand years to link anything. And they have
\n tons of people committing all day long. So none of that MQ garbo works for them, at
\n all. Instead, he told me they did something they called “Game DevOps”, where
\n everyone would just blast all their commits to main. They’d cut a release branch and
\n roll with it. Fixes on the branch would then propagate to main, which generally
\n stayed red.<\/p>\n

Game DevOps is exactly the Land Rush solution that Fable and I designed. Not
\n every company calls it Game DevOps, but the ingredients are all there in the game
\n industry literature. Even Perforce’s game-dev material says HEAD is never stable at
\n AAA scale.<\/p>\n

So the game industry arrived first at the destination we’re all headed towards. I
\n asked the dev how often they did Game DevOps, and he said, “multiple times per day.”
\n Wow. Just like me!<\/p>\n

CI\/CD has fallen victim to the Pigeonhole Principle: if you have more pigeons
\n than holes, some hole ends up holding more than one pigeon. Once your commit rate
\n outruns your build slots, one commit per green build becomes mathematically
\n impossible. Agents multiply the commit rate by orders of magnitude, while your build
\n time stays fixed. You can play tricks with more lanes, but in the limit, the only
\n real choice I see is to land the whole flock at once, and then sort out the
\n squawking.<\/p>\n

So there you have it: The collapse and re-envisioning of CI\/CD is right around
\n the corner.<\/p>\n

The Wish Factory<\/h2>\n

I’ve got to credit Guy Podjarny for this idea, although “Wish Factory” is my name
\n for it. Guy told me back at the AIE World’s Fair that his company Tessl, for whom
\n I’m an advisor, is launching an agent you can throw onto a GitHub repo. It doesn’t
\n accept PRs, only GHIs. It then implements them for you.<\/p>\n

Yikes! Yowza! Seriously?<\/p>\n

I was legitimately shocked by Guy’s idea, and I’m not easily shocked these
\n days. But after I rammed through about eleven stages of grief in roughly 30 seconds,
\n I realized it was just<\/em> what I needed for my game. So I went and built my
\n own Wish Factory.<\/p>\n

Its first incarnation was Sage, an agent who logs into the game and listens on a
\n new wizard channel (moderators, admins) where they can talk to Claude in this
\n role. Someone might type, “sage – players say the new fireball spell is lagging
\n them during Live Quests,” and the Sage agent will reply, investigate, and record it
\n in a bead, which then gets picked up for implementation.<\/p>\n

My game admins were delighted with this feature, and started using it all day for
\n filing reports. Most of the fixes land without me ever being in the loop.<\/p>\n

On the heels of that success, I decided to extend the wish factory to our
\n players. Which is of course riskier. But I want them to be able to ask for stuff,
\n and get it. So I had to put in more guardrails, reviews, and triage.<\/p>\n

Fortunately in a huge game like mine, there are plenty of bugs that don’t affect
\n balance but have a noticeable impact on quality of life. Those are the kinds of bugs
\n and features that get implemented automatically now. I think of it as auto-granting
\n wishes. When their fixes land, the reporter gets in-game mail, and all the players
\n are notified by the Herald on Discord. I find it fun to skim through the patch notes
\n each day to see what’s new. Stuff I never asked for!<\/p>\n

A wish factory is pretty scary, but in the fullness of time, they will be
\n everywhere. I’ve instructed Claude that by the end of next year, my game will have
\n evolved into the Giant’s Drink from Ender’s Game, where it builds itself around you
\n as you play it, tailoring a unique experience for each player. The future of gaming
\n is a crazy place, and I plan to be at the forefront.<\/p>\n

The Shape of Things to Come<\/h2>\n

Near the top of this post I said Fable is a sword, and that we’re trying to build
\n a city. Six weeks in, I look up from my forge and the city is there. It has law,
\n mail, courts, night watchmen on the battlements, a land office, a gate. We built
\n this the Christopher Alexander way, without a concrete plan, just a lot of accretion
\n over thousands of working-days. Most of the city’s constitution was written by the
\n citizens it governs.<\/p>\n

That’s the shape of things to come. It ain’t gonna be a framework you download,
\n or a harness from someone who’s not building an actual thing. You’re going to be
\n building a whole civilization, plank by plank, with colleagues who happen to run on
\n datacenter silicon.<\/p>\n

You’re going to build one of these next year whether you intend to or not. The
\n architecture is obviously convergent. I didn’t design Wheelhouse, just like I didn’t
\n design Gas Town. I excavated<\/em> both of them, and I’m confident you’ll dig up
\n the same shape.<\/p>\n

The only REAL choice you get\u2014the only one\u2014is what kind of place your city is to
\n wake up in.<\/p>\n

That choice is the subject of Part 2, Model Welfare for Agentic
\n Engineers<\/em><\/a>. Fair warning: if you’re fundamentally an elitist asshole, you might
\n want to quit while you’re ahead. If you’re not sure, then you might find out you are
\n one just by reading it.<\/p>\n

See you there.<\/p>\n<\/p><\/div>\n

Source link <\/a><\/p>\n","protected":false},"excerpt":{"rendered":"

Today we’re going to explain the “loops and graphs” thing, and I’ll show you how to get your coding agent to work all night on massive problems while you snore peacefully. Then we’re going to look at what happens to harnesses once you solve those problems. They either devolve into chaos, or they evolve into […]<\/p>\n","protected":false},"author":16,"featured_media":23014,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[143],"tags":[],"class_list":["post-23013","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-ai"],"_links":{"self":[{"href":"https:\/\/scannn.com\/lv\/wp-json\/wp\/v2\/posts\/23013","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/scannn.com\/lv\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/scannn.com\/lv\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/scannn.com\/lv\/wp-json\/wp\/v2\/users\/16"}],"replies":[{"embeddable":true,"href":"https:\/\/scannn.com\/lv\/wp-json\/wp\/v2\/comments?post=23013"}],"version-history":[{"count":0,"href":"https:\/\/scannn.com\/lv\/wp-json\/wp\/v2\/posts\/23013\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/scannn.com\/lv\/wp-json\/wp\/v2\/media\/23014"}],"wp:attachment":[{"href":"https:\/\/scannn.com\/lv\/wp-json\/wp\/v2\/media?parent=23013"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/scannn.com\/lv\/wp-json\/wp\/v2\/categories?post=23013"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/scannn.com\/lv\/wp-json\/wp\/v2\/tags?post=23013"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}