I really like the premise of this article because I am intensely interested in learning about software factories. As much as "software factory" is a buzzword, it's still SOTA and it's absolutely going to happen / keep happening in the tech industry over the next few years.
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).
I was bothered by the writing and fought through it, and carefully went through everything in the article... and you didn't miss anything. It's a tweet expanded to article length.
The factory analogy is tenuous, because real software is always bespoke, it’s not about producing gazillion copies of the same thing. Factories are about reliability and tolerances, aspects which are inherently intractable with LLMs.
One tragedy of this is that I stop reading when things don't make sense. There are a few connections in the article that seem tenuous. In the past I might have thought through it, considered the situation, and realized that the author had a different perspective and, if I shifted my mindset, there was a real insight there.
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.
In your second paragraph, that was true before AI-slop, at least for me. There was enough human slop that I couldn't bother to spend my time digging through it in the hope of finding a gem.
AI makes it worse, of course, because the ratio of slop to non-slop is worse.
LLMs being used as a tool in general (and in the future) to automate creation and maintenance of software is not mutually exclusive to one person using LLMs to create an article.
writing prose and writing code are two different things
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.
I like to delete all AI comments, and write my own. If I can't write a comment, I don't understand the code well enough to have my name on the commit. I often delete the resulting comment, because AI likes to add many more than are necessary.
I don’t think it’s possible to build a software factory unless you truly do not care about what you’re putting out.
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
I agree. I speak from experience because I actually went down this path for about a month. It is tempting. However, what I realized after some reflection is that there are just so many decisions that need to be made along the course of developing a product that it's never going to be possible to just one-shot it. There's a continuous feedback loop that is needed and agents aren't going to be the ones filling that role.
The fascination with "software factories" is strange. We don't have "bridge factories" or "skyscraper factories." We engineer those for the specific requirements from each individual project.
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.
> I don’t think it’s possible to build a software factory unless you truly do not care about what you’re putting out
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??
> I always come back to see shit that I have opinions about and need to polish
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.
Agree with you, overall -- and it's worthwhile to learn how to setup factories at various scales of problems, and one will always be in a situation where you need to decide whether you care about a particular part of the process, or can be okay with averages.
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.
Same experience. I've spent hours tweaking prompts, harnesses, skills and what not to have a simple (but non trivial) project completely managed by an agent.
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.
Despite the marketing, the "I" in AI doesn't (yet) stand for "intelligence". You're best off finding applications where you can easily write a rigorous, well-defined, easily evaluated acceptance criterion and then let the model, harness, etc go wild. This of course is also the case with "AI coding" technology that came before--genetic programming, NEAT, etc. It's not intelligent, and therefore limited in fundamental ways. You have to steer it to make it work. This is very fundamentally different from how factory workers operate.
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.
"Software factory" in overused and inaccurate term. Factories have an expensive tooling process and then create the same widget thousands/millions of times. Software can be copied effortlessly once made.
What people are describing is more like a "software kitchen" or "software machine shop".
or maybe more like a restaurant than a kitchen... with software development (like all product development) you need to bake in the user feedback loop
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)
Software is the factory. The utility is built right in. You can create lossless copies of the product nearly instantly and for free. It's a logistical miracle.
Exactly. Or at least software is a custom tooling.
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 definitely agree with the sentiment of this article, give or take. I've seen it at the place a previously worked at and now the place I currently work at: everybody wants AI to make coding faster and more efficient, but nobody is willing to take the risk of changing course and bending the firm's processes around what would actually make the agents more useful. Maybe this is more general than the qualms against "software factories," but it's pretty apparent that agentic development doesn't mesh with most of the development processes everyone was following prior to LLMs. Whenever a human is in the loop, it creates THE bottleneck which ultimately sets the pace. When humans can't fathom not being in the driver seat, then they're constantly in the loop, and nothing actually improves.
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.
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?
That blog post didn’t make a lot of sense to me. It’s saying to run CI in the merge queue. And also have CI be a script you can run locally. But also to replace CI?
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.
I think that's orthogonal to testing/ci/hooks and depends on what you're building and what stage you're at. Personally I would not run anything with real users without PRs and branch protection.
My `codex` design session landed on opening GitHub PRs and labeling some with `automerge` that we're comfortable landing on main after GH also verifies the checks.
if you're using claude code, i find you can instruct it to watch the pr and iterate on ci failures. I put this in an /issue skill that completes GitHub issues in the way I like then PR's or boots dev with QA instructions if it needs a human touch/eye. to drive this, I have a higher level bash script that makes a fresh worktree off of origin/main named after the issue and spawns a claude session running /issue.
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.
we have pre-commit hooks for fast tests (under a minute on a 2024 mac), a playwright script (smoke tests) that can be run on-demand locally, including setup and cleanup (~5 minutes). And on top of this we also have CI tests pre-merge (which we may drop soon)
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.
I think “software factory” just means automations where bots pick up tickets and spin up code changes. Maybe Stripe has that many well defined bugs but there’s no way it works if you’re building anything remotely complex. There’s just a lot of nuance that agents cannot pick up
"software factory" has always been a completely broken metaphor.
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.
People have, they arent putting them up for sale. Its the same with AI sales systems, if they work, they are worth far more than what they can be sold for as a product.
We are also sort of at a "bespoke factory" stage where building a factory means doing it around your specific codebase, each of which has their own needs and quirks. Just taking one of these wholesale from one company and using it at another would not work.
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.
Mixed thoughts on this article, here's my take:
There's no need to build a Software Factory. Every company already had a software factory in pre-AI – it is a socio-technical system delivering software (e.g. R&D). The input is the product ideas, the output is those ideas shipped to customers as code running in production. With AI we now have a chance to modernise the existing factory – speed it up. Code generation is solved, all the other bits of the factory are not: cheap&fast CI at scale, tech planning, code review, validation in production, incident diagnosis, etc. Naive way of "modernisation" is to give everyone a Claude Code subscription and call it done. Proper way is to figure out where the bottlenecks are and automate them with high-quality specialised AI agents. To surface the bottlenecks you need to pump in the throughput and see where it breaks – in the same way how you'd find an air leak in a tyre. The analogy with real factories is the story on how they were modernising the cotton mills when the electricity came in: retrofitting a big-ass electric engine (give everyone Claude/Codex) does not work, instead every part of the factory was modernised with smaller electric engines (specialised AI agents) – that's when the mill started to really increase its output. Humans are still there as building agents is REALLY hard, and it is not an end-state and more of a process: e.g. AI labs models are end-of-life every year and good luck just switching a model w/o re-engineering the prompts, evals, a/b tests, etc). But the emphasis really is on the SOCIO-technical system. Building those specialised AI agents is not only hard because of the non-determinism of underlying technology, but because those agents will interact with humans, create incentives, second order effects in a complex system. Every existing software factory is just a projection of a given engineering culture. Things you value as an R&D org, things you've optimised for over the years - they shape whatever the factory you have - with or w/o AI
The idea of a software factory long predates LLMs or any other form of automated full-program generation. The idea was to take full CI/CD pipelines that allow for rapid deployment of new components into a running system a la popular SaaS providers and web platforms that are usually single vendor or even single application, and extend the idea to a centralized production facility used by many different application vendors and consumer endpoints. Kessel Run in the US Air Force is the largest widely-touted success story I'm aware of, but I'm sure there must have been others.
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.
> its self-improvement loop ends where everyone’s does: “Humans review those suggestions as PRs on the factory definition and merge improvements."
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.
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.
This is the old idea of giving two teams the same project and letting a third team judge/merge a solution incorporating good parts of each. Just like the old idea, of course you would do this with infinite resources.
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.
Yeah, I'm amazed at how quickly I spotted this one. I didn't even read any prose since the first section header was visible before I started reading and somehow my brain jumped there first and it was a dead giveaway.
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.
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).
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.
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.
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
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.
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??
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.
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.
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.
https://www.danstroot.com/posts/2018-10-03-hammer-factories
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)
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.
And international distributuon and scaling is simple too, compared to physical goods.
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.
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?
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.
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.
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.
So to say that no one has built a software factory is a strong statement...and factually incorrect.
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.
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.
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.
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?
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.
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.
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.
Not a future I envisioned, but a preferable one.
I have all the AI subscriptions myself, I don't need a meet proxy. ai;dr
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.