Nobody has built a software factory
medium.com
medium.com
However, I can't read this, not because I refuse to -- I want to -- but because my the cogs in my mind just stop whirring at all of the LLM-isms, my eyes glaze over, and I stop being able to follow what the article is trying to communicate to me. I would love for the OP to call me out and correct me (that they haven't used LLMs to write this).
Seems like a disconnect there.
I can get good code out of LLMs. I can rarely get good writing out of them.
Maybe it's a skill issue, but it's not inherently a contradiction that they're better at some things than others. It's much easier to RL coding than writing.
There should be journalism classes on how to not sound like a bot.
Now I just assume that it's AI-slop and there's no other "way of thinking" that I can adopt to make it sensible. I'm surely missing out on learning through some human-written articles, but the volume of slop means that I can't spend all my time digging through nonsense in the hope that there's a gem of insight.
AI makes it worse, of course, because the ratio of slop to non-slop is worse.
Agent swarms, self learning, Ralph loops, execution DAGs, spending hours trying to convey my preferences into skills, yada yada — the reality is that no matter how long I spend trying to close the amortization gap between my expertise and (insert autonomous agent loop) … I always come back to see shit that I have opinions about and need to polish.
If you’re keeping on top of your craft, I just don’t think general purpose pretraining / RL is going to give you something which perfectly copies you. It can get closer and closer! But I’ve never seen agent work where I didn’t immediately start thinking of refinements …
I guess many things are okay if you’re okay with averages
In the article they talk of a swarm of agents autonomously speccing out the software and I can't help but wonder -- at that point, what are you creating, and for who??
Therefore I can't see how the "software factories" concept is actually feasible without a technological breakthrough. We may be no closer to it now than we were 25yr ago.
I think it's rooted in the idea that AI is going to "solve" software engineering when it's really only another tool that magnifies leverage. Same thing with traditional engineering and their computer-assisted tools. It doesn't "solve" engineering, but it does automate some of the repetitive things that aren't the biggest value-add.
Software isn't a manufactured product and that's where the disconnect is. You can't build software factories unless you don't care about the quality. For some companies, that might be fine, but I imagine that's a much smaller subset of the market than folks think.
The key constraint was keeping the quality bar high.
If I lower the quality bar and _only_ care about a working solution, this works great. And I dare not look at the implementation details if this is the outcome I care about.
But if I want a working solution _and_ have it done the right way, then I need to be in the loop at key points. Newer models, unfortunately, have made this problem worse. I will inevitably come back to some form of bad decisions, deviations or just slop. Left unattended, it snowballs into a pile of mess. At this point, I decide if I spend time fixing it or switch my mental model to not care about the quality.
The problem is worse when there's a team involved here. Fragmented tooling , prompts, harness, model causes more divergence. Especially in quality. Senior engineers become bottleneck as the quality enforcers.
I do like the revert rate metric that Posthog tracks. This can help incrementally build the tooling to a point it can be trusted and scales.
Definitely but can't the factory analogy still apply here?
We're now workers on a factory assembly line.
The assembly line still needs people to design and build machines, press buttons to operate machines, verify widgets are correct for their stage of assembly, and verify the final product is correct and ready to leave the assembly line.
Importantly it needs people that spot defects and send things back, and press the "big red button" if something is grossly wrong with the whole process.
The goal is to make this as efficient as possible working with our agents.
I don't think the agentic coding tools are anywhere close to making this awesome yet, but at the same time the best practices of "dev ops" need to be updated to involve agents.
I'm only saying that that I don't think one can automate the whole thing. After all, agents don't actually possess ... agency -- they require us to breath live into them. So at some part of the stack, there has to be a human, with an opinion, thinking about what they want.
Also: I don't aspire to be a worker, I aspire to seize the means of production.
You are not alone. Let's do it!
But isn't this the case with all code?
What people are describing is more like a "software kitchen" or "software machine shop".
like to torture the metaphors, i think we already have the factory (coding agents you can ask to manufacture software to a spec) but it's the whole process including QA, shipping, listening to users and iterating that has to happen over time (unless you have an accurate world simulation so you know exactly how your product will be received... and I know there are people working on that too but I'm skeptical)
And international distributuon and scaling is simple too, compared to physical goods.
A factory in the traditional sense is a process and infrastructure tuned to run efficiently that produces something of value that does not require highly skilled/expensive labor.
I DO see small instances where this is overcome, albeit, it occurs when risk is minimal, the work is non-critical, and the required environment is already available. For example, exploratory research of new features. Before, this would be quite costly and particularly cumbersome since the results may indicate that the new feature isn't viable and the work is basically "wasted." Now, you can send some agents to explore it for you and give you a "first pass" on the validity of the concept. You still end up with humans taking over immediately after (often to verify that first pass), but this has allowed a bit more efficiency in terms of understanding when investing that human time in exploratory investigation is appropriate and when it isn't. People are willing to give agents this level of control because the alternative is usually just a default "no."
Regardless, it seems obvious we're in a painful transition period where everyone in software can see that there's a ton of value here, but where everyone is simultaneously constrained by existing infrastructure, processes, expectations, etc., so as to not be willing or able to tap into that value. I suspect it won't be until there's just more new companies coming in without these existing constraints will the actual new version of these processes start to emerge and MAYBE some of the existing companies will be more willing to shake things up as needed to take advantage of it.
My experience, with the latest models, they do write code that looks correct/polished, but often do not fully solve the problem, or solve the wrong thing, or introduce un-needed complexity. By often, I mean at least 10%-15%, which is still a high enough error rate, that you don't want to let loose in even a trivial service, let alone a service that is on the critical side.
For now humans are absolutely needed in the loop.
Think of Netflix and Google sharing the same developer VDIs, build tooling, unit test framework, E2E test framework, promotion gates, and possibly even a common runtime platform. It's not something the commercial world tends to think much about, but in the military world you have many different vendor collaborating on a single C2 or comms system, but individually building their own production lines for each component. Centralize that and you can reduce procurement costs by de-duplicating effort, at least in theory.
Plenty of these have been built. I can buy that no one has built a fully-automated set of agents running on common compute, storage, and network substrates that can create, verify, and ship arbitrary software from vague natural language desirements alone, but that isn't the same thing and it's kind of a shame they decided to use an already in-use name for this. As many have pointed out, real physical factories don't do this, either. They build and ship the same thing with the same physical design in arbitrary quantities, which is a much easier problem to solve. Any Linux distro or mobile app store already does that.
So to say that no one has built a software factory is a strong statement...and factually incorrect.
Imagine a large multi dimensional grid. Each axis of the grid represents a spectrum of how a specific feature could be implemented. You thus have one axis per feature.
Now you plot a cloud of random points all over the grid and at each point have an agent build a solution where the features are expressed according to the corresponding intensity values at the point.
Now you go through and review the solutions you like, create more points around clusters where you kind of like what is going on, until the perfect product emerges.
Not a future I envisioned, but a preferable one.
You can already sort of do this in way that isn't insanely wasteful if your project has strong measures of correctness. But even then things like compilers have a very real axis for friction in "user/developer/agent experience".. doing it at scale involves some kind of LLM-as-Judge pointed at something which is not an objective value. So .. not only piling on additional false work, but work which is very likely to be incorrect/noisy.
I'm spending a relatively large amount of time waiting for CI to finish running, then clicking a button for an agent to fix failures, then waiting for CI to finish again. Might as well push that down into the core development loop.
Do folks have advice for doing this in practice?
Hooks in the harness? Pre-commit hooks? Different GitHub configurations?
Push to GH, run CI (in GHs relatively slow / fragile runners), poll GH APIs to see status and get errors, make changes. Then repeat.
The optimization is to bring running tests / fixing errors into the core agentic development loop, be much more confident that CI will pass on final pushed changes, then automatically queue / merge the changes.
2. Split out "syntactically correct" fast checks like linters into a standalone script and call it along with the slower checks in a full-check script
3. Set the fast-check script as a pre-commit hook and the full-check script as a pre-push hook.
4. Give the model instructions that it needs to run the fast-check script after every change and the full-check script when it thinks it's done.
5. Run full-check in CI.
Then you're good as long as the model doesn't bypass the pre-push hook, and even then CI will catch it.
Then push straight to main? Or do we need GitHub to help manage the queue https://docs.github.com/en/repositories/configuring-branches...
i'm not at the point where I'd go totally hands-off with code review / QA, so this setup is the right balance of automation for my current read on agent capability.
Like:
> A merge queue is a script you run to push to origin/main (instead of using a PR UI like we did back in the GitHub, all-human days).
This really doesn’t capture what a merge queue is. It’s a queue of change sets to merge, and CI has to pass on each change set before it can merge. There’s still a CI process. You can’t really enforce that just by having a bash script agents run locally, you need something at a higher level to enforce it, which is… CI.
CI doesn’t have to be slow, and the author isn’t even arguing for removing the tests.
Writing software is like building a factory. You try to find the optimal process to do something. This is a creative process and can never be straight forward. Using the software is running the factory.
This won't change with AI, since you never now all requirements beforehand and you always will have to iterate.
The only reason people are selling software factories is that customers like to imagine that this was possible. That a creative, iterative process can be perfectly planable and predictable.
This is just wrong.
That's because it's still painfully clear that genAI has no taste. It's a median content generator. And the median kinda sucks. Of course you still need people to review the output.
Long term, can we? If not, what do we do once we’re addicted to the new process and it’s impossible to get out and from?
We'll see if in the future, as people begin software projects this way, if there is more standardization. I suspect that there's just too much going on too fast at the moment to do it any other way, a decent factory for Opus 4.8 looks very different than one good for Astra, I'd guess. And models are just one axis.
110% ai
I think I may be developing defensive scanning strategies, that are probably useful for avoiding slop, but not good for my focus or general reading comprehension.
I have all the AI subscriptions myself, I don't need a meet proxy. ai;dr