Hello friends!
Welcome to another Sloth Bytes. I hope you’re doing well.
Latest Posts
If you’re new, or not yet a subscriber, or just plain missed it, here are some of our recent editions:
AI made PMs faster. Multiplayer mode is still broken.
A PM can summarize research, draft a PRD, and mock up a prototype before lunch. The hard part starts when the team has to decide what actually gets built.
Jira Product Discovery gives product teams one place to capture insights, prioritize ideas with consistent frameworks, and build living roadmaps stakeholders can rally around.
And because it’s connected to Jira, the context behind every decision stays with the work—so developers and their agents know not just what to build, but why.
AI helps PMs move faster. Jira Product Discovery helps the whole team build with confidence.
200+ Proven Ways to Make Money With AI in 2026
The next wave of millionaires will be people who figured out how to make AI work for them.
The window to get ahead is still open. But not for long.
Here are 200+ proven ways to make money with AI in 2026.
Sign up for Superhuman AI, the free daily newsletter read by 1M+ professionals, and get instant access to all 200+ ways to profit from AI this year.
Software factories
I've been noticing something lately.
Every week some company posts about how fast they're shipping now.
And when you dig into how they're doing it, some of them keep using the same term:
"Software factory."
It led me down a rabbit hole, and I wanted to talk about it because the potential is insane and it’s definitely going to change what your day as an engineer looks like.
What even is a software factory?
Vercel’s ai-sdk’s factory
Right now, most of us use AI like this:
You open Cursor or Claude Code.
You type "fix this bug."
You watch it work.
You read the changes.
LGTM, you hit accept.
Repeat.
In this process, you’re part of the loop. Nothing happens unless you're sitting there.
A software factory is what happens when you take yourself out of the loop and replace yourself with... I guess a conveyor belt.
It would look something like this:
Event comes in: A GitHub issue, a Slack message, a Sentry error, a Linear ticket.
Agent triages it: An agent reads the event, figures out if it's a bug, a feature, or a docs fix, and decides what to do next.
Agent implements it: A different agent spins up a sandbox, reproduces the problem, writes the fix, and runs the tests.
Agent reviews it: Another agent reads the diff and scores the risk.
A pull request gets made.
The pull request gets merged by a human (or by an agent, if it’s confident enough).
That's it. That's the factory.
Ticket goes in, specialized agents work on it, a PR comes out, and a human or a code review agent approves it.
Factory is a fitting name.
(You've technically been running a tiny factory if you've ever used Cursor cloud agents or GitHub's Copilot coding agent.)
Why is this suddenly a thing?
Mainly because code is getting cheap, but attention and effort are not.
AI made it basically free to generate code, issues, bug reports, and pull requests, but it did NOT make it free to read them.
So maintainers of popular open-source projects are drowning in PRs and issues.
Vercel said this about their AI SDK repo:
100+ new issues a month
By late June: over 1,000 open issues and almost 800 open PRs
Their take on it was brutally honest: no maintainer, no matter how good, can close that gap by working harder.
So they built a factory to make it easier. The results have been great:
The factory authored 25 to 35% of merged PRs
Over 75% of the issues closed in July were closed by the factory
Open issues dropped from 1,022 to 844
A human on the team still merged every single change
That last bullet is the important one. We'll come back to it.
Who's actually doing this?
A lot of companies are shipping real production code this way. Some use different names, but the overall workflow is the same:
The ones that say "factory" out loud:
Vercel built
ai-sdk-factorywith one agent per job: classifier, analyzer, implementer, reviewer. Every agent runs in an isolated Vercel Sandbox. It runs in public, so you can literally watch its PRs.Uber runs the biggest one anyone has published numbers for. Over 70% of their pull requests are attributed to local or cloud agents, engineers have built 3,600+ agent skills, and those skills run 30,000+ times a day. Managed agents handle code review, self-healing CI, on-call triage, and bug debugging, with humans reviewing and stepping in on escalations.
Cloudflare + Astro built a triage pipeline that reproduces the bug, diagnoses it, ships a preview build, waits for the reporter to confirm, THEN opens a PR. Astro's open issues went from 200+ to about 30. They open-sourced it as triagebot-action.
Warp launched "Warp Factories" in August. Their pitch is factories-as-code (think Terraform but for agents). They say ~30% of their own tasks go through it. (Obvious bias)
LaunchDarkly created a factory for their 66,000 lines of decade-old React frontend.
The ones doing the exact same thing with a different name:
Stripe calls them "Minions." They ship over 1,000 PRs to production every week. Humans review and approve.
Cursor says over 40% of internal PRs now come from cloud agents. (Obvious bias here)
Shopify has "River," a Slack bot. One in eight merged PRs across the entire company is coauthored by it.
Ramp built "Inspect." It started at 30% of merged PRs in January, but in a recent Linear writeup they say it’s now 75% of their merged PRs.
PostHog went from ~20% to 70% of monorepo PRs opened by an agent in four months. Their review bot "StampHog" auto-approves ~20% of PRs for about $300/month in tokens.
Spotify has "Honk." Mention it in Slack, and it comes back with a PR.
Cognition uses Devin to build Devin. One week they merged 659 Devin PRs. (Another obvious bias there)
Lights on vs lights off
The main part that people argue about or are trying to figure out:
Does a person even need to read it?
So now there are two variations of a software factory:
Lights on: a human merges it.
Lights off: an agent merges it. No humans at all.
StrongDM is an example of a lights-off factory. Their internal rules are literally:
Code must not be written by humans.
Code must not be reviewed by humans.
Three engineers write extremely detailed specs. Agents write the code, other agents test it against a fake "digital twin" of services like Okta and Slack, and the whole thing loops until it converges. Nobody looks at the diff.
They even open-sourced the agent that does it, called Attractor.
Is that insane? Kind of. Is it working for them? They say yes, but who knows.
So far, most companies are going with the lights-on approach and having humans review the end result, and it’ll most likely stay that way for major projects.
But before you go turn the lights off on your own repo, watch this talk.
Dex Horthy actually tried the lights-off approach. He ran a fully automated factory for four months where no human read a single line, and it did NOT go well. About three months in, the codebase had rotted so badly that one bug took weeks to untangle.
His argument is simple: coding models are trained to make the test pass, not to leave behind code a human (or another model) can still work in six months later. Nothing in the loop punishes bad design until it's too late.
He keeps it real about what these factories can actually do, and trust me, a lot of these companies are overhyping it. If you only watch one thing from this issue, make it this.
Why should you care?
You might be thinking "cool story bro, but none of this touches me."
Well, maybe not yet, but I think this workflow will get more common whether you like it or not. Even if it's overhyped right now (and a lot of it is), the company you work for is going to see those "70% of PRs" numbers and want that workflow too even if the quality goes down.
Which means it'll affect your job and what you study.
I think it’ll change these areas:
1. Instead of writing code, you’ll be reviewing it.
Every company above said some version of "review became the bottleneck." When the factory opens 40 PRs a day, someone has to know what good code looks like and catch the bad stuff.
That's a skill. It's a different skill from typing, and honestly it's the one AI will take the longest to figure out.
2. You’ll now work on "improving the factory."
Every failed run is a signal. Bad output? Fix the prompt, add an eval. Missing a credential? Provision it. Over time the factory handles stuff it couldn't be trusted with last week.
That's just... engineering. Pointed at the thing that does the work instead of the work itself.
3. You’ll be creating specialized factories.
Factories aren’t that hard to make. I’m serious, you can build a tiny one right now.
You can tell an agent to create one with your requirements, or use one of these tools and templates:
Vercel's eve template is a one-click deploy with four agents (classifier, analyzer, implementer, reviewer). Label an issue
factory, get a draft PR. Merge stays human.Astro's triagebot-action is a label-driven state machine on GitHub Actions. Best one to read if you want to understand how the pieces fit.
Warp Factories if you want the "as code" version. Closed beta, so apply and wait.
Ramp's Inspect spec if you want the ugly internal version with sandbox snapshots and a Slack classifier.
Since factories are so easy to make, it only makes sense that your job will eventually ask you to build some for specific areas. And the one rule everyone agrees on for factories:
Start with one small job.
Get that one boring thing reliable, measure it for a few weeks, then add the next station.
Warp thinks this will be as common as CI/CD in a few years, and looking at the results from other companies, I don't think that's crazy.
Let me know what you think. Are you building one? Are you scared of one? Reply and tell me.
If you want to keep learning
AI agents explained — the loop, tools, and memory that every one of these factories is built on.
CI/CD explained — the pipeline these factories plug into. If you don't get CI, you won't get factories.
Docker for dummies — every factory agent runs in a sandbox. This is what a sandbox is.
Programming feels different — my take on what changes for you as a builder when the code isn't the point anymore.
That’s all from me!
Have a great week, be safe, make good choices, and have fun coding.
If I made a mistake or you have any questions, feel free to comment below or reply to the email!
See you all next week.
What'd you think of today's email?
Want to advertise in Sloth Bytes?
If your company is interested in reaching an audience of developers and programming enthusiasts, you may want to advertise with us here.
