The Republic of Slop

If you were shipping code before the master branch got renamed, and before a full week of collective human life went into arguing main versus master because nobody involved had anything to deliver, then you remember what this job used to pay.

It paid well because it was engineering. You had to know what a computer was. Not the metaphor. The machine: how much memory it had, what happened when it ran out, why the disk was slow and the cache was not.

Most people holding the title today graduated from a Discord server and a Minecraft guild.

I know how that sentence reads coming from me, so here is the disclosure up front. My own confession is already published. I built an operating system with an LLM and put my name on twenty thousand commits I did not write. I am writing this from the other side of that autopsy, which is the only reason I can describe the inside of it.

Why a Republic¶

I chose the word deliberately. There is no king here and no emperor to depose. A monarchy would be easier. You locate the throne, you make your case to whoever is sitting on it, and the answer comes back from someone who can be held to it.

The republic offers nothing that solid. It has citizens who control the flow: the merge button on a repository with four hundred stars, or the algorithm’s attention for a week. Nobody granted them that and nobody can take it away. They govern by volume.

The consoling part is that none of it is hereditary. Most of these citizens will perish the ordinary way, when somebody finally reads the thing they called an innovation, recognizes the work it was taken from, and says that name out loud. No coup required. It only takes a reader with a long memory.

The Citizens¶

Now I watch people pick up languages the way tourists pick up hats. Rust, Zig, Odin, Haskell, Elixir, Erlang, whatever the model vomited on Friday. Monday it is on the LinkedIn profile. By Tuesday they have moved on to the next one, and there is no artifact anywhere that proves the stop happened.

Some of these I am still working through, and I have been doing this for twenty years.

The language is innocent here. Every one of those was built by serious people solving a real problem, and any of them will reward the decade you give it. The crime is choosing a material without being able to say what it costs.

Two people can commit the same Cargo.toml. One picked Rust after watching a process idle at 700MB and deciding that was unacceptable. The other picked it because a model called it blazingly fast. The file is identical. Only one of them can answer a question about it.

The opposite keeps happening to me. Most of the internet knows me as Seuros, and my GitHub avatar is a cat, so a lot of people know me as the cat guy and never pick up a name at all. Then they meet Abdelkader, and somewhere in the conversation they tell me about this cat guy in Morocco who does exactly the kind of work I should be looking at, and that I really ought to meet him.

Meet myself?

It happens often enough that I have stopped correcting it, because I like what it says about the order of things. The work traveled far enough to find its way back to me with no face attached. A profile is a claim you make about yourself. A repository a stranger recommends to your face is a fact about you.

The Census¶

Here is the founding condition of the republic: no citizen has ever felt a constraint.

The dev box has 128GB of RAM and 4TB of SSD. The model running on top of it will generate any quantity of code you ask for, and it has no mechanism for saying this is too much. The cloud underneath bills instead of refusing. Nothing anywhere in that stack is capable of saying no.

Then the artifact ships to a VPS with 2GB of RAM and a 256GB disk, which is what a server looks like when someone pays for it out of their own pocket.

The census figure for the republic is 700MB. That is what the closest competitor to my analytics binary needs at idle. Not under load. Idle, counting nothing, serving nobody, holding 700MB because that is simply what it weighs when it is asleep.

Nobody decided that. It accumulated, on machines where it never showed up as pain.

Cement and Playdough¶

I think about languages as materials.

Ruby is playdough. Warm, soft, made for hands. You can reshape it while the thing is running: monkeypatch a class in production, open an object and ask it what it thinks it is, change your mind at 2 AM with the process still up. It was built for children in the one sense that matters. It will not hurt you if you swallow it.

Rust and C are cement. There is a window while it is wet, and after that the shape is the shape. Changing your mind means a jackhammer and a weekend.

When I want to build a piece of art, I reach for playdough every time. When I want something that sits on a server for two years holding 7MB and asking nobody for anything, I reach for cement.

Both of those are correct. Telling them apart is the entire job, and it requires having chosen wrong at least once with your own money on the line.

The 78 Unsafe Blocks¶

All of that is abstract. Here is a scene.

I sent a patch to a Rust project with four hundred stars, maintained by a former Rubyist. The work was close to mechanical: change edition = "2021" to edition = "2024" in Cargo.toml, then repair what that breaks.

What it breaks is environment variables. In edition 2024, std::env::set_var and remove_var became unsafe functions. This is not the compiler being precious. Setting an environment variable mutates process-global state with no lock while any other thread may be reading it, and that race existed on the day the function was written. Rust spent years arguing about it and then decided to stop letting it pass unannotated. Try it yourself on a 2024 crate and the toolchain says error[E0133]: call to unsafe function set_var is unsafe and requires unsafe block.

So my patch wrapped 78 call sites in unsafe {}. Most of them were environment variables.

The reply came back long and confident, explaining that I was adding bugs to his codebase. It still had the em dashes attached, which is how I knew which of us had written our own sentences. Then the actual objection surfaced: he had promised his community he would never use unsafe.

Hold that promise up against the patch. I did not add 78 unsafe operations. I labeled 78 unsafe operations his code had been performing since the day he shipped it. The hazard was already in production. My patch changed nothing except whether a reader could see it.

He had promised his community something the language had already taken away from him, and he did not know, because the compiler had not gotten around to telling him yet.

Here is the part that belongs to this post rather than to him. He had a model open the whole time. He used it to compose the rejection. He never used it to ask the only question that mattered, which was whether the patch was correct. It would have told him. It knows the edition guide better than either of us do. He asked for a lawyer when what he needed was a reviewer, and the machine did the job it was handed, beautifully, for the wrong side.

That is the governing style of the republic. Authority arrives fluent, formatted, and unchecked, and the citizen holding the merge button never finds out he was wrong.

The Receipts¶

I am not against Rust. I write it daily. Every MCP server I run is Rust, and I learned it the slow way, by porting gems until the borrow checker stopped being an opinion and turned into a colleague. state_machines was one of those.

I ended up naming a pattern out of it. matryoshka: one repository that ships a gem and a crate, same behavior on both sides of the FFI. breaker_machines lives that way, 0.17.0 on RubyGems and 0.17.1 on crates.io, the same circuit breaker in both materials because I wanted to know what each one cost me.

Which brings me to the receipt.

In March I published The Bloat Industry. I needed pageview counting. The industry offered me eight containers, including Kafka and ZooKeeper, to watch over my visitor counts like a distributed consensus problem. So I wrote kaunta in Go instead. One binary, 15MB.

Then I rewrote it in Rust. 7MB.

The competitor needs 700MB to do the same job. A hundred times the memory to increment a number and write it to disk.

That gap is not malice and it is not stupidity. It is what happens when every person who touched the code had 128GB and a model that never pushed back. Nobody in that chain ever watched a 2GB box start swapping, so the weight was never information. It was just a number in a dashboard nobody was billed for.

Terrence Davis in the HipChat¶

I worked at the same company as Terry Davis. It took me years to find that out.

It was one of those places that hires in volume, and I was a junior. To me he was the guy who had done time at Ticketmaster and ran a YouTube channel, and in our chat he was listed as Terrence Davis. I watched a little of the channel and could not tell what I was looking at. He was also casually racist, so I decided he was not worth my time and kept my distance. That was the right call, and it still cost me something.

It clicked in 2024. I had a Claude instance sorting my contacts by who actually mattered, and it moved Terrance up the list. A language model doing secretarial work reached a conclusion about my own address book that I had failed to reach for years.

Look at the shape of that failure. Terrence on the account, Terry on the internet, and I never joined the two together. It is the same split I was laughing about a few sections ago, when somebody tells me there is a cat guy in Morocco I really ought to meet. The difference is which way it runs. Mine is a joke I get to enjoy, because the work found its way back to me. This one ran the other direction. I had the man in my chat window and let the name on the account decide he was nobody worth my attention.

Terry built TempleOS alone. Roughly a hundred thousand lines, a compiler and a graphics stack, on an architecture that answered to nobody else’s conventions, over ten years. I have written about him before, so I will skip the eulogy and keep the one part that matters here.

He did not use Claude. He did not use GPT. He used God.

Believe whatever you like about the source. He could account for every line. You could point at anything in that tree and get an answer, sometimes a divine one, always a specific one. That is the bar this post is measuring against. Not the line count, and not the architecture. The ability to answer for what you shipped.

Hold on to the ten years. You are going to need them in about four paragraphs.

Four Thousand Commits in a Day¶

Now take a pull request from this month.

NousResearch/hermes-agent #102117. 4,271 commits across 2,655 files. Opened on a Thursday morning, merged the following afternoon, about twenty five hours end to end. The description reports the codebase going from 1,063,826 source lines to 698,363, a 34% cut, with gateway/run.py coming down from 34,847 lines to 5,512. The title promises zero behavior change.

Sit with the numbers on the left of those arrows. A million lines, thirty four thousand of them in a single Python file. That is ten TempleOS’s, and the deletion alone was worth more than three, reviewed and merged inside a day.

The diff is big enough to break the tooling around it. GitHub refuses to render parts of it, and the API declines to compute a diffstat at all, reporting zero changed files until you page through the file list and count the 2,655 yourself.

The PR body contains the sentence that should have halted everything: nobody, human or agent, could hold a subsystem in their head. That is the author stating the problem correctly on his way to merging it into main.

Then there is the review history, which I did not expect.

Somebody did review it. An engineer at the company, ethernet8023, left sixteen line-level comments and formally requested changes on the third. On the fourth, that review was dismissed. A colleague approved it instead. It merged that afternoon.

Now the part that made me sit up, because it is the argument of this post arriving on its own.

I was going to tell you that touching a subsystem in FreeBSD gets you a man materializing out of retirement to explain why the guard you removed was put there in 1997. Two of them showed up in this thread without being asked.

Enji Cooper, FreeBSD committer, went and read the commits. He found behavior changes in the first one he examined: tools/skill_usage.py moves a flock call outside its try-finally block, which suppresses errors the lock can raise. He noted that tools like black compare the AST before and after precisely to substantiate the zero-behavior-change claim that this PR merely asserts, and that he saw no equivalent scrutiny here.

I seriously recommend reverting this given the attitude in accepting this much LoC without a ton of review.

He also said what the project actually is. hermes-agent works by being granted permission by a user to reach files and resources on that user’s behalf, which turns an unreviewed million-line refactor into a security posture rather than a matter of taste. He was blunt about where that leaves him:

I’m definitely going to stop using this project because of this laissez-faire approach to reviewing code.

And he closed with the question the entire republic needs to answer:

This change was so large GitHub refuses to render the commits and some of the content. How can you be certain that this change is sane as a reviewer?

Nick Price, FreeBSD kernel committer, was more economical:

“Reviewed by Hermes Agent”

“We investigated ourselves and found that we did nothing wrong”

The rest of the thread is lgtm 🤙🏼, LGTM final boss, and one person asking how three humans reviewed 2,655 files.

None of it changed anything. The request for changes was dismissed, the approval came from inside the house, and the code is in main.

That is the difference between a process and a costume. FreeBSD’s reviewers can stop me because the project grants them the authority to stop me. These two arrived with the same rigor and a specific bug in hand, and they were scenery.

The XZ backdoor kept coming to mind while I wrote this, and I had the wrong lesson attached to it. That attack took a patient human two years of social engineering, and it worked because the changes were shaped so nobody would look closely. The conclusion everyone drew afterward was that open source needs more eyes on the code.

This thread corrects me. The eyes were there. A FreeBSD committer read the commits and found a genuine behavior change in the first one he opened, inside a PR whose title promises none. An engineer inside the company filed sixteen objections and formally blocked it. The merge landed on schedule regardless.

Reading was never the scarce resource. Authority is. You do not need a hostile actor when the objection is a formality that somebody with merge rights can dismiss on a Friday.

The First Human to See the Brick¶

Here is the argument nobody answers for me.

Take the best engineers in any ecosystem. Hand them a million lines to review. Then add one clause to the contract: if this application is breached, you go to prison.

No amount of money gets that signed. Not for lack of skill. Because nobody can honestly certify a million lines they did not write, and every good engineer knows it about themselves.

That is where this ends up regardless. Applications assembled like LEGO, with nobody in the chain whose reading had the power to keep a piece out. Open a box of LEGO and you are the first human being to see that brick. Everything upstream was injection-molded and boxed without a person looking at any individual piece, and it works, because a brick has one job and a tolerance that a machine can verify.

Software is getting the same supply chain without any of the tolerances.

Paid in T-Shirts¶

I keep a list of checks I run against new projects in this category. Everything I have pointed it at came back vulnerable, and all of it was holding real data.

My favorite tell is SQLite in production, which is a legitimate choice being made by people who cannot defend it. Once somebody is inside, the whole database leaves over scp as a single file. No privilege boundary to cross, no query to craft. You copy the building.

I documented one of these already. I registered as super admin on an influencer’s platform through a registration form sitting on the admin route, and the system courteously offered me seven days to confirm my email before it would suspend my unlimited access.

I do not report most of what I find anymore, and this is the part I promised to expose at the top.

You disclose. The report goes into a model. The model writes the patch and the thank-you note. The pipeline redeploys it. You get a T-shirt with their logo on it, which converts you into advertising for the company whose security you just repaired for free. No job offer. Not even a consultation.

Do not assume there is a person at the end of that chain. I have had my own pull request approved by Copilot, approved again by CodeRabbit, and auto-merged on the strength of those two agreeing with each other. The owner was hiking with friends while it happened. As far as the repository was concerned this was correct procedure, because the rule said two approvals and two approvals arrived.

Two models agreeing is not a second opinion. It is one opinion delivered twice, by systems trained on the same corpus with the same blind spots, and the merge queue counts it as consensus. My code went into somebody else’s project without a human reading a line of it.

My patch was fine. That is not the point. Nobody who owns that repository knows it was fine.

I am not alone in stopping. Greg Molnar and I talk about this privately, and both of us are sitting on things that are going off under our feet, because the alternative is donating labor to a pipeline that launders it into a changelog entry. The bug gets closed. Nobody learns anything. The next one ships Friday.

Zero Ownership¶

Peter Steinberger built Clawdbot in about an hour by wiring WhatsApp to Claude. He called himself a Claudoholic, Claude Code was his daily driver, and he said both in public.

Here is the part that matters. None of the presentation was his. Clawd already belonged to Anthropic: the 8-bit pixel crustacean that greets you at the top of a Claude Code session, drawn in June 2024, trademarked alongside the Claude name. Steinberger named his project after the creature on the loading screen of the product he was wrapping. He did not choose an orange lobster and discover a coincidence. He took Anthropic’s orange lobster, #da7756 against a brand palette of #d97757, and the color arrived with everything else he lifted.

So the shipped product was Anthropic’s model behind Anthropic’s mascot under a name built out of Anthropic’s name, assembled in sixty minutes and pointed at WhatsApp.

On January 27, 2026, Anthropic’s lawyers arrived, because Clawd was too close to Claude. His public account of it: “I was forced to rename the account by Anthropic. Wasn’t my decision.” Asked why he could not simply drop the d and be Clawbot, he replied that he was “Not allowed to.”

Forced. Not his decision. Regarding a name he had taken off the loading screen of somebody else’s product.

He renamed it Moltbot, the community hated that, and three days later it became OpenClaw, repositioned as model-agnostic agentic infrastructure. On February 15 he joined OpenAI to lead their personal agent work, and OpenClaw went to a foundation.

Then came the reviews.

Anthropic, he explained, copies popular features into a closed harness and locks out open source. This from the author of a sixty-minute WhatsApp wrapper around somebody else’s model, shipped in a lobster costume named after that model, and the complaint now arrives from inside OpenAI, where the openness is load-bearing in the branding and nowhere else.

Nobody made him open source it. That was his own decision, published under a license he selected himself, and a license is a document whose entire job is to say what happens next. You built your product on another company’s model, gave the design away in public, and then objected when that company shipped something similar. That is the arrangement read back to you. It is not a betrayal.

He also diagnosed Claude’s plan mode as “a hack Anthropic had to bolt on because the model is too impulsive,” a model that jumps straight into coding instead of thinking first. With GPT 5.2, he says, you can just talk to it.

Plan mode is not a patch for an impulsive model. It is a seatbelt for an impulsive operator.

I know this because I built my own harness in 2022 and called it LevAIthan on Rails. It had no plan mode, since plan mode would not exist for years. No MCP, no agent loop, no undo, and no git integration. When the model changed a file, the file was changed, and the version that had been working ten minutes earlier was gone for good.

That is what taught me to ask correctly. Nothing downstream was going to catch a bad instruction, so the instruction had to be right at the moment it left my hands. Plan mode eventually shipped and I did not need it, because the discipline it enforces was the only thing standing between me and a destroyed working tree for four months.

So yes, if you are running 87 things an hour, every one of them needs a guard. That is not a defect in the model. That is an operator with too many tabs open, asking the tooling to supply the attention he is not bringing to it.

He may be right about all of it. It changes nothing about authorship. He approved every line that shipped under that name, and when the output is slop, the tool did not decide to ship it. Blaming the model afterward is the purest available expression of what this republic runs on: authority without ownership, available to anyone who can generate faster than he can read.

All of which would be a footnote if it stayed on hobby projects. It has not. I am watching old friends put this into healthcare, insurance, infrastructure, and the military industry, where the failure mode is not a purple dashboard.

They are writing more lines per week than Terry wrote in his lifetime. Zero ownership, and zero understanding of what went out the door.

The Fix Is a Smaller Machine¶

You do not fix this with a bigger model. A bigger model is a faster way to generate the same unweighed code.

You fix it by putting the citizens in front of a machine that can say no. Deploy it to the 2GB box. Watch the resident set size. Let the swap file teach the lesson that no amount of prompting will, because the box does not care how confident you sounded and it does not negotiate.

I spent four months and $8,000 learning that a system which cannot push back teaches you nothing.

The smaller machine only teaches weight, though. Ownership needs the other test, the one Terry passed every day and this republic cannot survive: point at any line and ask why it is there. Not what it does, which a model will narrate back to you in confident paragraphs. Why it exists, what breaks when it goes, and who paid to find that out.

If nobody in the room can answer, you do not have a codebase. You have a boxed set, and you are the first human to see the brick.

The reading is the work. The measuring is the rest of it.

And when somebody else does the reading, arrives with a real objection, and turns out to be right, the only question worth asking about your project is whether they had the power to stop you. Enji Cooper had everything else. A specific bug in a named file, and a question nobody in that thread could answer. What he did not have was a button.

Give somebody the button.