15 ms·

Software factories and the agentic moment

• mellosouls 9mo ago
  Having submitted this I would also suggest the website admin revisit their testing; its very slow on my phone. Obviously fails on aesthetics and accessibility as well. Submitted for the essay.
  • pityJuke 9mo ago
    Haha yeah if I scroll on my iPhone 15 Pro it literally doesn’t load until I stop.
  • foolserrandboy 9mo ago
    I get the following on safari on iOs: A problem repeatedly occurred on (url)
    • throwaway0123_5 9mo ago
      On iOS Safari it loads and works decent for me, but w/ iOS Firefox and Firefox Focus doesn't even load.
  • deleted 9mo ago
    [deleted]
  • pengaru 9mo ago
    Sounds like you're experiencing an "agentic moment".
  • belter 9mo ago
    Lets hope the agents in their factory can fix it asap...
• beklein 9mo ago
  Relevant blog post from simonw: https://simonwillison.net/2026/Feb/7/software-factory/ https://simonwillison.net/2026/Feb/7/software-factory/
• easeout 9mo ago
  > A problem repeatedly occurred on "https://factory.strongdm.ai/ https://factory.strongdm.ai/".
• simonw 9mo ago
  This is the stealth team I hinted at in a comment on here last week about the "Dark Factory" pattern of AI-assisted software engineering: https://news.ycombinator.com/item?id=46739117#46801848 https://news.ycombinator.com/item?id=46739117#46801848 I wrote a bunch more about that this morning: https://simonwillison.net/2026/Feb/7/software-factory/ https://simonwillison.net/2026/Feb/7/software-factory/ This one is worth paying attention to to. They're the most ambitious team I've see exploring the limits of what you can do with this stuff. It's eye-opening.
  • enderforth 9mo ago
    This right here is where I feel most concerned > If you haven’t spent at least $1,000 on tokens today per human engineer, your software factory has room for improvement Seems to me like if this is true I'm screwed no matter if I want to "embrace" the "AI revolution" or not. No way my manager's going to approve me to blow $1000 a day on tokens, they budgeted $40,000 for our team to explore AI for the entire year. Let alone from a personal perspective I'm screwed because I don't have $1000 a month in the budget to blow on tokens because of pesky things that also demand financial resources like a mortgage and food. At this point it seems like damned if I do, damned if I don't. Feels bad man.
    • navanchauhan 9mo ago
      I think corporate incentives vs personal incentives are slightly different here. As a company trying to experiment in this moment, you should be betting on token cost not being the bottleneck. If the tooling proves valuable, $1k/day per engineer is actually pretty cheap. At home on my personal setup, I haven't even had to move past the cheapest codex/claude code subscription because it fulfills my needs ¯\_(ツ)_/¯. You can also get a lot of mileage out of the higher tiers of these subscriptions before you need to start paying the APIs directly.
      • rune-dev 9mo ago
        How is 1k/day cheap? Even for a large company? Takes like this are just baffling to me. For one engineer that is ~260k a year.
• navanchauhan 9mo ago
  (I’m one of the people on this team). I joined fresh out of college, and it’s been a wild ride. I’m happy to answer any questions!
  • simonw 9mo ago
    I know you're not supposed to look at the code, but do you have things in place to measure and improve code quality anyway? Not just code review agents, but things like "find duplicated code and refactor it"?
    • navanchauhan 9mo ago
      A few overnight “attractor” workflows serve distinct purposes: * DRYing/Refactoring if needed * Documentation compaction * Security reviews
  • steveklabnik 9mo ago
    More of a comment than a question: > Those of us building software factories must practice a deliberate naivete This is a great way to put it, I've been saying "I wonder which sacred cows are going to need slaughtered" but for those that didn't grow up on a farm, maybe that metaphor isn't the best. I might steal yours. This stuff is very interesting and I'm really interested to see how it goes for you, I'll eagerly read whatever you end up putting out about this. Good luck! EDIT: oh also the re-implemented SaaS apps really recontextualizes some other stuff I’ve been doing too…
    • axus 9mo ago
      > "I wonder which sacred cows are going to need slaughtered" Or a vegan or Hindu. Which ethics are you willing to throw away to run the software factory? I eat hamburgers while aware of the moral issues.
    • navanchauhan 9mo ago
      This was an experiment that Justin ran: one person fresh out of college, and another with a long, traditional career. Even though all three of us have very different working styles, we all seem to be very happy with the arrangement. You definitely need to keep an open mind, though, and be ready to unlearn some things. I guess I haven’t spent enough time in the industry yet to develop habits that might hinder adopting these tools. Jay single-handedly developed the digital twin universe. Only one person commits to a codebase :-)
• rhrthg 9mo ago
  Can you disclose the number of Substack subscriptions and whether there is an unusual amount of bulk subscriptions from certain entities?
  • simonw 9mo ago
    I recently passed 40,000 but my Substack is free so it's not a revenue source for me. I haven't really looked at who they are - at some point it would be interesting to export the CSV of the subscribers and count by domains, I guess. My content revenue comes from ads on my blog via https://www.ethicalads.io/ https://www.ethicalads.io/ - rarely more than $1,000 in a given month - and sponsors on GitHub: https://github.com/sponsors/simonw https://github.com/sponsors/simonw - which is adding up to quite good money now. Those people get my sponsors-only monthly newsletter which looks like this: https://gist.github.com/simonw/13e595a236218afce002e9aeafd75cd0 https://gist.github.com/simonw/13e595a236218afce002e9aeafd75... - it's effectively the edited highlights from my blog because a lot of people are too busy to read everything I put out there! I try to keep my disclosures updated on the about page of my blog: https://simonwillison.net/about/#disclosures https://simonwillison.net/about/#disclosures
    • andersmurphy 9mo ago
      Is this article sponsored by StrongDM?
      • simonw 9mo ago
        No.
• deleted 9mo ago
  [deleted]
• japhyr 9mo ago
  > That idea of treating scenarios as holdout sets—used to evaluate the software but not stored where the coding agents can see them—is fascinating. It imitates aggressive testing by an external QA team—an expensive but highly effective way of ensuring quality in traditional software. This is one of the clearest takes I've seen that starts to get me to the point of possibly being able to trust code that I haven't reviewed. The whole idea of letting an AI write tests was problematic because they're so focused on "success" that `assert True` becomes appealing. But orchestrating teams of agents that are incentivized to build, and teams of agents that are incentivized to find bugs and problematic tests, is fascinating. I'm quite curious to see where this goes, and more motivated (and curious) than ever to start setting up my own agents. Question for people who are already doing this: How much are you spending on tokens? That line about spending $1,000 on tokens is pretty off-putting. For commercial teams it's an easy calculation. It's also depressing to think about what this means for open source. I sure can't afford to spend $1,000 supporting teams of agents to continue my open source work.
  • verdverm 9mo ago
    Do you know what those hold out twats should look like before thoroughly iterating on the problem? I think people are burning money on tokens letting these things fumble about until they arrive at some working set of files. I'm staying in the loop more than this, building up rather than tuning out
  • Lwerewolf 9mo ago
    Re: $1k/day on tokens - you can also build a local rig, nothing "fancy". There was a recent thread here re: the utility of local models, even on not-so-fancy hardware. Agents were a big part of it - you just set a task and it's done at some point, while you sleep or you're off to somewhere or working on something else entirely or reading a book or whatever. Turn off notifications to avoid context switches. Check it: https://news.ycombinator.com/item?id=46838946 https://news.ycombinator.com/item?id=46838946
  • dist-epoch 9mo ago
    I wouldn't be surprised if agents start "bribing" each other.
• codingdave 9mo ago
  > If you haven’t spent at least $1,000 on tokens today per human engineer, your software factory has room for improvement At that point, outside of FAANG and their salaries, you are spending more on AI than you are on your humans. And they consider that level of spend to be a metric in and of itself. I'm kinda shocked the rest of the article just glossed over that one. It seems to be a breakdown of the entire vision of AI-driven coding. I mean, sure, the vendors would love it if everyone's salary budget just got shifted over to their revenue, but such a world is absolutely not my goal.
  • kaffekaka 9mo ago
    If the output is (dis)proportionally larger, the cost trade off might be the right thing to do. And it might be the tokens will become cheaper.
    • obirunda 9mo ago
      Tokens will become significantly more expensive in the short term actually. This is not stemming from some sort of anti-AI sentiment. You have two ramps that are going to drive this. 1. Increase demand, linear growth at least but likely this is already exponential. 2. Scaling laws demand, well, more scale. Future better models will both demand higher compute use AND higher energy. We cannot underestimate the slowness of energy production growth and also the supplies required for simply hooking things up. Some labs are commissioning their own power plants on site, but this is not a true accelerator for power grid growth limits. You're using the same supply chain to build your own power plant. If inference cost is not dramatically reduced and models don't start meaningfully helping with innovations that make energy production faster and inference/training demand less power, the only way to control demand is to raise prices. Current inference costs, do not pay for training costs. They can probably continue to do that on funding alone, but once the demand curve hits the power production limits, only one thing can slow demand and that's raising the cost of use.
  • dewey 9mo ago
    It would depend on the speed of execution, if you can do the same amount of work in 5 days with spending 5k, vs spending a month and 5k on a human the math makes more sense.
• CubsFan1060 9mo ago
  I can't tell if this is genius or terrifying given what their software does. Probably a bit of both. I wonder what the security teams at companies that use StrongDM will think about this.
  • verdverm 9mo ago
    I doubt this would be allowed in regulated industries like healthcare
• g947o 9mo ago
  Serious question: what's keeping a competitor from doing the same thing and doing it better than you?
  • simonw 9mo ago
    That's a genuine problem now. If you launch a new feature and your competition can ship their own copy a few hours later the competitive dynamics get really challenging! My hunch is that the thing that's going to matter is network effects and other forms of soft lockin. Features alone won't cut it - you need to build something where value accumulates to your user over time in a way that discourages them from leaving.
    • CubsFan1060 9mo ago
      The interesting part about that is both of those things require some sort of time to start. If I launch a new product, and 4 hours later competitors pop up, then there's not enough time for network effects or lockin. I'm guessing what is really going to be needed is something that can't be just copied. Non-public data, business contracts, something outside of software.
    • verdverm 9mo ago
      Marketing and brand are still the most important, though I personally hope for a world where business is more indie and less winner take all You can see the first waves of this trend in HN new.
      • andersmurphy 9mo ago
        Wouldn't the incumbents with their fantastic distribution channels, brand, lockin, marketing, capital and own models just wipe the floor with everyone as talent no longer matters?
        • groundtruthdev 9mo ago
          Short answer no. In a world where AI reliably generates software, companies will bypass SaaS vendors, even the large ones, and go straight to the best LLM providers for tailored solutions. Brand, lock-in, and capital won’t save traditional vendors.
• wrs 9mo ago
  On the cxdb “product” page one reason they give against rolling your own is that it would be “months of work”. Slipped into an archaic off-brand mindset there, no?
  • verdverm 9mo ago
    We make this great, just don't use it to build the same thing we offer Heat death of the SaaSiverse
• d0liver 9mo ago
  > As I understood it the trick was effectively to dump the full public API documentation of one of those services into their agent harness and have it build an imitation of that API, as a self-contained Go binary. They could then have it build a simplified UI over the top to help complete the simulation. This is still the same problem -- just pushed back a layer. Since the generated API is wrong, the QA outcomes will be wrong, too. Also, QAing things is an effective way to ensure that they work _after_ they've been reviewed by an engineer. A QA tester is not going to test for a vulnerability like a SQL injection unless they're guided by engineering judgement which comes from an understanding of the properties of the code under test. The output is also essentially the definition of a derivative work, so it's probably not legally defensible (not that that's ever been a concern with LLMs).
• threecheese 9mo ago
  So much of this resonated with me, and I realize I’ve arrived at a few of the techniques myself (and with my team) over the last several months. THIS FRIGHTENS ME. Many of us sweng are either going be FIRE millionaires, or living under a bridge, in two years. I’ve spent this week performing SemPort; found a ts app that does a needed thing, and was able to use a long chain of prompts to get it completely reimplemented in our stack, using Gene Transfer to ensure it uses some existing libraries and concrete techniques present in our existing apps. Now not only do I have an idiomatic Python port, which I can drop right into our stack, but I have an extremely detailed features/requirements statement for the origin typescript app along with the prompts for generating it. I can use this to continuously track this other product as it improves. I also have the “instructions infrastructure” to direct an agent to align new code to our stack. Two reusable skills, a new product, and it took a week.
  • beepbooptheory 9mo ago
    Sorry if rude but truly feel like I am missing the joke. This is just LinkedIn copypasta or something right?
    • threecheese 9mo ago
      My post? Shiiiii if that’s how it comes across I may delete it. I haven’t logged into LI since our last corp reorg, it was a cesspool even then. Self promotion just ain’t my bag I was just trying to share the same patterns from OPs documentation that I found valuable within the context of agentic development; seeing them take this so far is was scares me, because they are right that I could wire an agent to do this autonomously and probably get the same outcomes, scaled.
  • cbeach 9mo ago
    Please let’s not call ourselves “swengs” Is it really that hard to write “developer” or “engineer”?
    • threecheese 9mo ago
      Amusingly I use that term that to avoid the “not an engineer” and “I don’t make websites” comments. But noted, Tu.
• Herring 9mo ago
  $100 says they're still doing leetcode interviews. If everyone can do this, there won't be any advantage (or profit) to be had from it very soon. Why not buy your own hardware and run local models, I wonder.
  • navanchauhan 9mo ago
    I would spend those $100 on either API tokens or donate to a charity of your choice. My interview to join this team was whether I could build something of my choosing in under an hour with any coding agent of my choice. No local model out there is as good as the SOTA right now.
    • Herring 9mo ago
      > My interview to join this team was whether I could build something of my choosing in under an hour with any coding agent of my choice. You should have led with that. I think that's actually more impressive; anyone can spend tokens.
• CuriouslyC 9mo ago
  Until we solve the validation problem, none of this stuff is going to be more than flexes. We can automate code review, set up analytic guardrails, etc, so that looking at the code isn't important, and people have been doing that for >6 months now. You still have to have a human who knows the system to validate that the thing that was built matches the intent of the spec. There are higher and lower leverage ways to do that, for instance reviewing tests and QA'ing software via use vs reading original code, but you can't get away from doing it entirely.
  • cronin101 9mo ago
    This obviously depends on what you are trying to achieve but it’s worth mentioning that there are languages designed for formal proofs and static analysis against a spec, and I have suspicions we are currently underutilizing them (because historically they weren’t very fun to write, but if everything is just tokens then who cares). And “define the spec concretely“ (and how to exploit emerging behaviors) becomes the new definition of what programming is.
    • svilen_dobrev 9mo ago
      > “define the spec concretely“ (and unambiguously. and completely. For various depths of those) This always has been the crux of programming. Just has been drowned in closer-to-the-machine more-deterministic verbosities, be it assembly, C, prolog, js, python, html, what-have-you There have been a never ending attempts to reduce that to more away-from-machine representation. Low-code/no-code (anyone remember Last-one for Apple ][ ?), interpreting-and/or-generating-off DSLs of various level of abstraction, further to esperanto-like artificial reduced-ambiguity languages... some even english-like.. For some domains, above worked/works - and the (business)-analysts became new programmers. Some companies have such internal languages. For most others, not really. And not that long ago, the SW-Engineer job was called Analyst-programmer. But still, the frontier is there to cross..
      • kmac_ 9mo ago
        Code is always the final spec. Maybe the "no engineers/coders/programmers" dream will come true, but in the end, the soft, wish-like, very undetailed business "spec" has to be transformed into hard implementation that covers all (well, most of) corners. Maybe when context size reaches 1G tokens and memory won't be wiped every new session? Maybe after two or three breakthrough papers? For now, the frontier isn't reached.
• hnthrow0287345 9mo ago
  Yep, you definitely want to be in the business of selling shovels for the gold rush.
• eclipsetheworld 9mo ago
  I have been working on my own "Digital Twins Universe" because 3rd-party SaaS tools often block the tight feedback loops required for long-horizon agentic coding. Unlike Stripe, which offers a full-featured environment usable in both development and staging, most B2B SaaS companies lack adequate fidelity (e.g., missing webhooks in local dev) or even a basic staging environment. Taking the time to point a coding agent towards the public (or even private) API of a B2B SaaS app to generate a working (partial) clone is effectively "unblocking" the agent. I wouldn't be surprised if a "DTU-hub" eventually gains traction for publishing and sharing these digital twins. I would love to hear more about your learnings from building these digital twins. How do you handle API drift? Also, how do you handle statefulness within the twins? Do you test for divergence? For example, do you compare responses from the live third-party service against the Digital Twin to check for parity?
• rileymichael 9mo ago
  > In rule form: - Code must not be written by humans - Code must not be reviewed by humans as a previous strongDM customer, i will never recommend their offering again. for a core security product, this is not the flex they think it is also mimicking other products behavior and staying in sync is a fools task. you certainly won't be able to do it just off the API documentation. you may get close, but never perfect and you're going to experience constant breakage
  • andersmurphy 9mo ago
    Right but how many unsuspecting customers like you do they need to have before they can exit?
    • simonw 9mo ago
      They actually "exited" a few weeks ago - acquired by Delinea: https://delinea.com/news/delinea-strongdm-to-unite-redefine-identity-security-for-the-ai-era https://delinea.com/news/delinea-strongdm-to-unite-redefine-... From what I've heard the acquisition was unrelated to their AI lab work, it was about the core business.
      • andersmurphy 9mo ago
        Thanks for the reply (always enjoy your sqlite content). It's definitely going to be interesting to see how all these AI labs playout when they are how the core business is built.
  • simonw 9mo ago
    Important to note that this is the approach taken by their AI research lab over the past six months, it's not (yet) reflective of how they build the core product.
    • gabrieledarrigo 9mo ago
      What have they actually built?
• simianwords 9mo ago
  I like the idea but I'm not so sure this problem can be solved generally. As an example: imagine someone writing a data pipeline for training a machine learning model. Anyone who's done this knows that such a task involves lots data wrangling work like cleaning data, changing columns and some ad hoc stuff. The only way to verify that things work is if the eventual model that is trained performs well. In this case, scenario testing doesn't scale up because the feedback loop is extremely large - you have to wait until the model is trained and tested on hold out data. Scenario testing clearly can not work on the smaller parts of the work like data wrangling.
• noosphr 9mo ago
  I was looking for some code, or a product they made, or anything really on their site. The only github I could find is: https://github.com/strongdm/attractor https://github.com/strongdm/attractor Building Attractor Supply the following prompt to a modern coding agent (Claude Code, Codex, OpenCode, Amp, Cursor, etc): codeagent> Implement Attractor as described by https://factory.strongdm.ai/ Canadian girlfriend coding is now a business model. Edit: I did find some code. Commit history has been squashed unfortunately: https://github.com/strongdm/cxdb https://github.com/strongdm/cxdb There's a bunch more under the same org but it's years old.
  • yomismoaqui 9mo ago
    I don't know if that is crazy or a glimpse of the future (could be both). PS: TIL about "Canadian girlfriend", thanks!
  • simonw 9mo ago
    There's actual code in this repo: https://github.com/strongdm/cxdb https://github.com/strongdm/cxdb
    • lunar_mycroft 9mo ago
      I've looked at their code for a few minutes in a few files, and while I don't know what they're trying to do well enough to say for sure anything is definitely a bug, I've already spotted several things that seem likely to be, and several others that I'd class as anti-patterns in rust. Don't get me wrong, as an experiment this is really cool, but I do not think they've succeeded in getting the "dark factory" concept to work where every other prominent attempt has fallen short.
      • simonw 9mo ago
        Out of interest, what anti-patterns did you see? (I'm continuing to try to learn Rust!)
        • 9mo ago
• layer8 9mo ago
  So, what does DM stand for?
  • navanchauhan 9mo ago
    Domain Model (https://strongdm.com https://strongdm.com)
    • layer8 9mo ago
      Thanks. I’m unable to find the term “domain model” on the website.
      • navanchauhan 9mo ago
        It’s part of the “lore” that gets passed down when you join the company. Funnily enough, the marketing department even ran a campaign asking, “What does DM stand for?!”, and the answer was “Digital Metropolis,” because we did a design refresh. I just linked the website because that’s what the actual company does, and we are just the “AI Lab”
        • DonHopkins 9mo ago
          Dungeon Master, obviously!
    • socialcommenter 9mo ago
      Do you have any successful examples of software build by this factory in a main that isn't AI-adjacent? I.e. not an SaaS clone, not another code linter/database/whatever? Can the factory build, e.g. a crypto trading algorithm, an e-commerce site, etc.? To come up with a software spec for the agents to follow, first you need to understand what your business is and where the money is.
  • dude250711 9mo ago
    Doomy marketing?
• srcreigh 9mo ago
  This is just sleight of hand. In this model the spec/scenarios are the code. These are curated and managed by humans just like code. They say "non interactive". But of course their work is interactive. AI agents take a few minutes-hours whereas you can see code change result in seconds. That doesn't mean AI agents aren't interactive. I'm very AI-positive, and what they're doing is different, but they are basically just lying. It's a new word for a new instance of the same old type of thing. It's not a new type of thing. The common anti-AI trope is "AI just looked at <human output> to do this." The common AI trope from the StrongDM is "look, the agent is working without human input." Both of these takes are fundamentally flawed. AI will always depend on humans to produce relevant results for humans. It's not a flaw of AI, it's more of a flaw of humans. Consequently, "AI needs human input to produce results we want to see" should not detract from the intelligence of AI. Why is this true? At a certain point you just have Kolmogorov complexity, AI having fixed memory and fixed prompt size, pigeonhole principle, not every output is possible to be produced even with any input given specific model weights. Recursive self-improvement doesn't get around this problem. Where does it get the data for next iteration? From interactions with humans. With the infinite complexity of mathematics, for instance solving Busy Beaver numbers, this is a proof that AI can in fact not solve every problem. Humans seem to be limited in this regard as well, but there is no proof that humans are fundamentally limited this way like AI. This lack of proof of the limitations of humans is the precise advantage in intelligence that humans will always have over AI.
  • sebastiennight 9mo ago
    > Recursive self-improvement doesn't get around this problem. Where does it get the data for next iteration? From interactions with humans. It wasn't true for AlphaGo, and I see no reason it should be true for a system based on math. It makes sense that a talented mathematician who's literally made of math, could build a slightly better mathematician, and so on.
    • AnimalMuppet 9mo ago
      AlphaGo was able to recursively self-improve within the domain of the game of go, which has an astonishingly small set of rules. We're asking AIs to have data that covers the real physical world, plus pretty much all of human society and culture. Doing self-improvement on that without external input is a fundamentally different proposition than doing it for go.
• AlexeyBrin 9mo ago
  Code must not be written by humans Code must not be reviewed by humans I feel like I'm taking crazy pills. I would avoid this company like the plague.
• neya 9mo ago
  The solution to this problem is not throwing everything at AI. To get good results from any AI model, you need an architect (human) instructing it from the top. And the logic behind this is that AI has been trained on millions of opinions on getting a particular task done. If you ask a human, they almost always have one opinionated approach for a given task. The human's opinion is a derivative of their lived experience, sometimes foreseeing all the way to the end result an AI cannot foresee. Eg. I want a database column a certain type because I'm thinking about adding an E-Commerce feature to my CMS later. An AI might not have this insight. Of course, you can't always tell the model what to do, especially if it is a repeated task. It turns out, we already solved this decades ago using algorithms. Repeatable, reproducible, reliable. The challenge (and the reward) lies in separating the problem statement into algorithmic and agentic. Once you achieve this, the $1000 token usage is not needed at all. I have a working prototype of the above and I'm currently productizing it (shameless plug): https://designflo.ai https://designflo.ai However - I need to emphasize, the language you use to apply the pattern above matters. I use Elixir specifically for this, and it works really, really well. It works based off starting with the architect. You. It feeds off specs and uses algorithms as much as possible to automate code generation (eg. Scaffolding) and only uses AI sparsely when needed. Of course, the downside of this approach is that you can't just simply say "build me a social network". You can however say something like "Build me a social network where users can share photos, repost, like and comment on them". Once you nail the models used in the MVC pattern, their relationships, the software design is pretty much 50% battle won. This is really good for v1 prototypes where you really want best practices enforced, OSWAP compliant code, security-first software output which is where a pure agentic/AI approach would mess up.
• politelemon 9mo ago
  > we transitioned from boolean definitions of success ("the test suite is green") to a probabilistic and empirical one. We use the term satisfaction to quantify this validation: of all the observed trajectories through all the scenarios, what fraction of them likely satisfy the user? Oh, to have the luxury of redefining success and handwaving away hard learned lessons in the software industry.
• stego-tech 9mo ago
  IT perspective here. Simon hits the nail on the head as to what I'm genuinely looking forward to: > How do you clone the important parts of Okta, Jira, Slack and more? With coding agents! This is what's going to gut-punch most SaaS companies repeatedly over the next decade, even if this whole build-out ultimately collapses in on itself (which I expect it to). The era of bespoke consultants for SaaS product suites to handle configuration and integrations, while not gone, are certainly under threat by LLMs that can ingest user requirements and produce functional code to do a similar thing at a fraction of the price. What a lot of folks miss is that in enterprise-land, we only need the integration once. Once we have an integration, it basically exists with minimal if any changes until one side of the integration dies. Code fails a security audit? We can either spool up the agents again briefly to fix it, or just isolate it in a security domain like the glut of WinXP and Win7 boxen rotting out there on assembly lines and factory floors. This is why SaaS stocks have been hammered this week. It's not that investors genuinely expect huge players to go bankrupt due to AI so much as they know the era of infinite growth is over. It's also why big AI companies are rushing IPOs even as data center builds stall: we're officially in a world where a locally-run model - not even an Agent, just a model in LM Studio on the Corporate Laptop - can produce sufficient code for a growing number of product integrations without any engineer having to look through yet another set of API documentation. As agentic orchestration trickles down to homelabs and private servers on smaller, leaner, and more efficient hardware, that capability is only going to increase, threatening profits of subscription models and large AI companies. Again, why bother ponying up for a recurring subscription after the work is completed? For full-fledged software, there's genuine benefit to be had with human intervention and creativity; for the multitude of integrations and pipelines that were previously farmed out to pricey consultants, LLMs will more than suffice for all but the biggest or most complex situations.
  • theshrike79 9mo ago
    “API Glue” is what I’ve called it since forever Stuff comes in from an API goes out to a different API. With a semi-decent agent I can build what took me a week or two in hours just because it can iterate the solution faster than any human can type. A new field in the API could’ve been a two day ordeal of patching it through umpteen layers of enterprise frameworks. Now I can just tell Claude to add it, it’ll do it up to the database in minutes - and update the tests at the same time.
• amarant 9mo ago
  "If you haven't spent at least $1,000 on tokens today per human engineer, your software factory has room for improvement" Apart from being a absolutely ridiculous metric, this is a bad approach, at least with current generation models. In my experience, the less you inspect what the model does, the more spaghetti-like the code will be. And the flying spaghetti monster eats tokens faster than you can blink! Or put more clearly: implementing a feature will cost you a lot more tokens in a messy code base than it does in a clean one. It's not (yet) enough to just tell the agent to refactor and make it clean, you have to give it hints on how to organise the code. I'd go do far as to say that if you're burning a thousand dollars a day per engineer, you're getting very little bang for your tokens. And your engineers probably look like this: https://share.google/H5BFJ6guF4UhvXMQ7 https://share.google/H5BFJ6guF4UhvXMQ7
  • kakugawa 9mo ago
    It's short-term vs long-term optimization. Short-term optimization is making the system effective right now. Long-term optimization is exploring ways to improve the system as a whole.
  • Garlef 9mo ago
    Maybe Management will finally get behind refactoring
    • amarant 9mo ago
      Damn, I was already on board with using coding agents. Consider me welded to the deck at this point!
• galoisscobi 9mo ago
  What has strongdm actually built? Are their users finding value from their supposed productivity gains? If their focus is to only show their productivity/ai system but not having built anything meaningful with it, it feels like one of those scammy life coaches/productivity gurus that talk about how they got rich by selling their courses.
• dist-epoch 9mo ago
  Gas Town, but make it Enterprise.
  • mcapodici 9mo ago
    Nailed it
• mccoyb 9mo ago
  Effectively everyone is building the same tools with zero quantitative benchmarks or evidence behind the why / ideas … this entire space is a nightmare to navigate because of this. Who cares without proper science, seriously? I look through this website and it looks like a preview for a course I’m supposed to buy … when someone builds something with these sorts of claims attached, I assume that there is going to be some “real graphs” (“these are the number of times this model deviated from the spec before we added error correction …”) What we have instead are many people creating hierarchies of concepts, a vast “naming” of their own experiences, without rigorous quantitative evaluation. I may be alone in this, but it drives me nuts. Okay, so with that in mind, it amounts to heresay “these guys are doing something cool” — why not shut up or put up with either (a) an evaluation of the ideas in a rigorous, quantitative way or (b) apply the ideas to produce an “hard” artifact (analogous, e.g., to the Anthropic C compiler, the Cursor browser) with a reproducible pathway to generation. The answer seems to be that (b) is impossible (as long as we’re on the teet of the frontier labs, which disallow the kind of access that would make (b) possible) and the answer for (a) is “we can’t wait we have to get our names out there first” I’m disappointed to see these types of posts on HN. Where is the science?
  • simonw 9mo ago
    Honestly I've not found a huge amount of value from the "science". There are plenty of papers out there that look at LLM productivity and every one of them seems to have glaring methodology limitations and/or reports on models that are 12+ months out of date. Have you seen any papers that really elevated your understanding of LLM productivity with real-world engineering teams?
    • mccoyb 9mo ago
      No, I agree! But I don’t think that observation gives us license to avoid the problem. Further, I’m not sure this elevates my understanding: I’ve read many posts on this space which could be viewed as analogous to this one (this one is more tempered, of course). Each one has this same flaw: someone is telling me I need to make a “organization” out of agents and positive things will follow. Without a serious evaluation, how am I supposed to validate the author’s ontology? Do you disagree with my assessment? Do you view the claims in this content as solid and reproducible? My own view is that these are “soft ideas” (GasTown, Ralph fall into a similar category) without the rigorous justification. What this amounts to is “synthetic biology” with billion dollar probability distributions — where the incentives are setup so that companies are incentivized to convey that they have the “secret sauce” … for massive amounts of money. To that end, it’s difficult to trust a word out of anyone’s mouth — even if my empirical experiences match (along some projection).
• svilen_dobrev 9mo ago
  how about the elephant.. Apart of business-spec itself, Where-from all those (supply-chain) API specs/documentation are going to come? After, say, 3 iterations in this vein, of the API-makers themselves ??
• Alex_L_Wood 9mo ago
  >If you haven't spent at least $1,000 on tokens today per human engineer, your software factory has room for improvement …What am I even reading? Am I crazy to think this is a crazy thing to say, or it’s actually crazy?
  • delusional 9mo ago
    It's crazy if you're an engineer. It's pretty common for middle managers to quantify "progress" in terms of "spend". My bosses bosses boss like to claim that we're successfully moving to the cloud because the cost is increasing year over year.
    • FuckButtons 9mo ago
      Appropriate username.
    • dexwiz 9mo ago
      Growth will be proportional to spend. You can cut waste later and celebrate efficiency. So when growing there isn't much incentive to do it efficiently. You are just robbing yourself of a potential future victory. Also it's legitimately difficult to maximize growth while prioritizing efficiency. It's like how a body builder cycles between bulking and cutting. For mid to long term outlooks it's probably the best strategy.
      • direwolf20 9mo ago
        Is this satire? Throwing money into a bottomless pit is the opposite of success. Growth is proportional to spend if and only if spend is proportional to growth. You can't just assume it's the case.
  • gassi 9mo ago
    My favorite conspiracy theory is that these projects/blog posts are secretly backed by big-AI tech companies, to offset their staggering losses by convincing executives to shovel pools of money into AI tools.
• chopete3 9mo ago
  "These go to 11" The context behind it https://m.youtube.com/watch?v=4xgx4k83zzc&pp=ygUOdGhlc2UgZ28gdG8gMTE%3D https://m.youtube.com/watch?v=4xgx4k83zzc&pp=ygUOdGhlc2UgZ28...
• engelo_b 9mo ago
  [dead]
  • rimbo789 9mo ago
    I think the insurance industry is will take a simpler route: humans will be held 100% responsible. Any decisions made by the ai will be the responsibility of the human instructing that ai. Always. I think this will act as a brake on the agentic shift as a whole.
    • engelo_b 9mo ago
      [dead]
      • rimbo789 9mo ago
        Yes, that is why I strongly support sticking to 100% human responsibility for “black-box” errors.
    • mrguyorama 9mo ago
      This is how it works for things decided by algorithm right now, and it has done absolutely nothing to stymie companies making decisions by algorithm and simply making sure you sign away your right to sue before you interact with them.
  • Ucalegon 9mo ago
    They just are not going to provide insurance to companies who use AI because the liability costs are not worth it to them since they cannot actual calculate risks, it is already happening [0]. Its the one thing that a lot of the evangelists of using AI for entire products have come to realize or they aren't actually dealing with B2B scenarios where indemnity comes into play. That or they are lying to insurance companies and their customers, which is a... choice. [0] https://futurism.com/future-society/insurance-cyber-risk-ai https://futurism.com/future-society/insurance-cyber-risk-ai
• kykat 9mo ago
  I'm just going to say: When opening the "twins" (bad clones) screenshots, I pressed the right key to view the next image, and surprise, the next "article" of the top navigation bar was loaded, instead of showing the next image. Is this the quality we should expect from agentic? From my experiments with claude code, yes, the UX details are never there. Especially for bigger features. It can work reasonably well independently up to a "module" level (with clear interfaces). But for full app design, while technically possible, the UX and visual design is just not there. And I am very not attracted to the idea of polishing such an agentic apps. A solution could be: 1. The boss prompts the system with what he wants. 2. The boss outsources to india the task of polishing the rough edges. === More on the arrow keys navigation: Pressing right on the last "Products" page loops to the first "Story" page, yet pressing left on the first page does nothing. Typical UX inconsistency of vibe coded software.
• swisniewski 9mo ago
  Some of this is people trying to predict the future. And it’s not unreasonable to assume it’s going there. That being said, the models are not there yet. If you care about quality, you still need humans in the loop. Even when given high quality specs, and existing code to use as an example, and lots of parallelism and orchestration, the models still make a lot of mistakes. There’s lots of room for Software Factories, and Orchestrators, and multi agent swarms. But today you still need humans reviewing code before you merge to main. Models are getting better, quickly, but I think it’s going to be a while before “don’t have humans look at the code” is true.
• janlucien 9mo ago
  [dead]
• Dumblydorr 9mo ago
  What would happen if these agents are given a token lifespan, and are told to continually spend tokens to create more agentic children, and give their genetic and data makeup such as it is to children that it creates with other agents sexually potentially, but then tokens are limited and they can not get enough without certain traits. Wouldn’t they start to evolve to be able to reproduce more and eat more tokens? And then they’d be mature agents to take further human prompts to gain more tokens? Would you see certain evolutionary strategies reemerge like carnivores eating weaker agents for tokens, eating of detritus of old code, or would it be more like evolution of roles in a company? I assume the hurdles would be agents reproducing? How is that implemented?
  • tayo42 9mo ago
    I'll have 1 of what ever this guy's got please.
    • Dumblydorr 9mo ago
      Huffing a lot of Gastown and having some hallucinations of my own. We have to show these machines we can out hallucinate them! Hi future overlords training on this data
    • throwaway29473 9mo ago
      Evolution is a great meta heuristic optimization technique for bumpy functions, it seems natural to propose using it to tune agent performance.
• lubujackson 9mo ago
  I explored the different mental frameworks for how we use LLMs here: https://yagmin.com/blog/llms-arent-tools/ https://yagmin.com/blog/llms-arent-tools/ I think the "software factory" is currently the end state of using LLMs in most people's minds, but I think there is (at least) one more level: LLMs as applications. Which is more or less creating a customized harness. There is a lot more that is possiible once we move past the idea that harnesses are just for workflow variations for engineers.
• bluesnowmonkey 9mo ago
  > The Digital Twin Universe is our answer: behavioral clones of the third-party services our software depends on. We built twins of Okta, Jira, Slack, Google Docs, Google Drive, and Google Sheets, replicating their APIs, edge cases, and observable behaviors. Came to the same conclusion. I have an integration heavy codebase and it could hardly test anything if tests weren't allowed to call external services. So there are fake implementations of every API it touches: Anthropic, Gemini, Sprites, Brave, Slack, AgentMail, Notion, on and on and on. 22 fakes and climbing. Why not? They're essentially free to generate, it's just tokens. I didn't go as far as recreating the UI of these services, though, as the article seems to be implying based on those screenshots. Just the APIs.
  • adisingh13 9mo ago
    how are you implementing agentmail? would love to know more
    • bluesnowmonkey 9mo ago
      I'm building a platform of AI agents, and each agent can have its own email address. AgentMail handles that. You create an inbox via their REST API and they POST to your webhook when mail arrives. On the agent side, it just gets tools: send email, reply to email, list inbox, read message. Those tools call the AgentMail API. So the fake implements the same interface.. same send/reply/list/read methods, but recording calls instead of making HTTP requests. You can pre-populate inboxes with test messages, simulate "username taken" errors, etc. AgentMail is actually one of the simpler fakes because there's no internal state to maintain. Sending a message doesn't affect what you'd read back from your own inbox. Some of the other fakes (like the database or file storage) need to actually simulate state in memory so writes are visible to subsequent reads. This one is closer to a stub.
• mkoubaa 9mo ago
  Cringe-worthy at best
• groundtruthdev 9mo ago
  To the article’s author: what is the timeline for removing human engineers from your own organization?
  • danny_codes 9mo ago
    I imagine it's even easier to remove the CEO/Executive staff. Actually, why have anyone there at all? Surely this company can LLM their way to having no staff whatsoever!
    • groundtruthdev 9mo ago
      Yeah, extraordinary claims need some internal consistency before external evangelism. I’d expect the same from other companies whose CEOs make these kinds of claims, like Nvidia and Anthropic.
• cadamsdotcom 9mo ago
  This is part of a new trend towards “harness engineering”. You should automate away as much of the software construction and validation process as possible, but also the QA and integration (which includes debugging).. take yourself progressively out of those loops, that’s the new job. For example you can iteratively automate code review. Every time you notice an issue during review, pop open your coding agent and ask it how it might be instructed to catch such a thing. There’s going to be an 80/20 rule here - you probably can’t eliminate every issue, but there’s bound to be low hanging fruit. We will see where this goes!
• joshribakoff 9mo ago
  Renaming or redefining “tests” because the LLM gets confused by the word is the tell.
• geraneum 9mo ago
  > with the second revision of Claude 3.5 (October 2024), long-horizon agentic coding workflows began to compound correctness rather than error. What does it mean to compound correctness? Like negative acceleration in rate of errors? How does that compound? Unseriously!
  • navanchauhan 9mo ago
    The model could start building on top of things it had successfully built before instead of just straight up exponential error propagation
• ricardobeat 9mo ago
  > If you haven't spent at least $1,000 on tokens today per human engineer So a four person team should be spending close to $1M/year, double each engineer’s salary, on AI alone? To get the output of one junior engineer who smokes crack and has his memory wiped every twenty minutes?
  • direwolf20 9mo ago
    Doubling? Try quadrupling outside of silicon valley. He is saying hire 4x as many engineers and make 3/4 of them AI. So much for the 10x productivity increase — that's 0.25x!
  • simonw 9mo ago
    If that team is producing 4x what they would be producing without LLMs then spending 2x their salaries on tooling sees financially rational to me. (I know, that's a very big "if".)
    • coder23853 9mo ago
      There are many ways "producing" can be quantified (LOC, PRs, features) such that 4x production does not correlate to a 4x in value of the product (quality, revenue).
    • ricardobeat 9mo ago
      There is no mention of a productivity increase anywhere in this piece. 2x? Maybe, but at this price you can hire another very senior engineer, and have both be 50% more productive with a $200/month AI spend.
      • simonw 9mo ago
        Measuring productivity in software development is notoriously hard, but the demos I saw them give when the team of three people had been working together for three months showed more work then I would ever expect from a team of that size over that amount of time. They already had their own custom agent harness and digital twin imitations of Jira and Slack and Okta and a bunch of other custom tooling. It looked to me like way more than a 2x or 4x thing.
• kittbuilds 9mo ago
  [dead]
• xyzsparetimexyz 9mo ago
  Most of what people like this are actually creating is blogslop.
• danshapiro 9mo ago
  If you'd like to try this yourself, you can build an "attractor" by just pointing claude code at their llms.txt. Or if you'd like to save some tokens, you can clone my go version. https://github.com/danshapiro/kilroy https://github.com/danshapiro/kilroy This version has a Claude Code skill to help. Tell it to use it's skill to create a dotfile from your requirements. Then tell it to run that dotfile with kilroy.
• softwaredoug 9mo ago
  A lot of examples of creating clones of existing products don't resonate with new products we build For example, most development work involves discovering correctness, not writing to a fullproof spec (like cloning slack) Usually work goes like: * Team decides some vague requirement * Developer must implement requirement into executable decisions Now I use Claude Code to do step 2 now, and its great. But I'm looking over whether the implementation's little decisions actually do what the business would want. Or more accurately, I'm making decisions to the level of specificity that matters to the problem at hand. I have to try, backtrack, and rebuild all the time when my assumptions get broken. In some cases decisions have low specificity: I could one-shot a complex feature (or entire app if trying to test PMF or something). In other cases, the tradeoffs in 10 lines of code become crucially important.
• s0ck_r4w 9mo ago
  Do we give them 24 or 48 hours before somebody hacks their service?
• groundtruthdev 9mo ago
  In this hypothetical world where AI reliably generates software, large and small software providers alike are out of luck. Companies will go straight to LLMs or open-source models, fine-tune them for their needs, and run them on in-house hardware as costs fall, spreading expenses across departments. Even LLM providers won’t be safe. Brand, lock-in, and incumbent status won’t save anyone. The advantage goes to whoever can integrate, customize, and scale internally. Hypothetically is the keyword.
  • simonw 9mo ago
    Sounds like a great opportunity for my company! Who can I hire to help me figure out how to do this stuff?
  • energy123 9mo ago
    What are the other consequences of unlimited cheap reliable quality software? It's hard to think about but feels more important than just SaaS companies going bankrupt.
• mol_ai 9mo ago
  [dead]
• deathanatos 9mo ago
  … all this hype, and just … where are the macro level results? GitHub is seemingly having more outages than ever before, and MS is pretty directly involved in the AI hype; should they be a beacon of how great AI's output is? Yet obvious bugs that have persisted for years still languish. My day job is more and more feeling like I'm fighting just to get tooling or services to do the most basic things they were allegedly designed to do. On the other hand, you have AI companies claiming "we built a browser from scratch" — and then having that claim utterly eviscerated. I cannot fathom going to my boss and requesting "$1,000/day per engineer" for AI — that's an absurd amount of money. And yet, whenever I actually do try to get AI to meet the road … it is just query and query after clarifying query that humans would not and do not need. E.g., trying to ask clarifying questions about tsc, and TS, and … just wrong answer after wrong answer, or even just misunderstanding the question entirely. Trying to file a support ticket in big clouds now requires wading through AI slop that doesn't solve anything, just to get to a human whose writing feels suspiciously like you've been shoveled a second dose of slop. Like I just finished a quarter long ticket with GCP on "IAM is not functioning to spec, and we can clearly and concisely prove it" to get back a very long form "we don't care".
• raincole 9mo ago
  > The Digital Twin Universe is our answer: behavioral clones of the third-party services our software depends on. We built twins of Okta, Jira, Slack, Google Docs, Google Drive, and Google Sheets, replicating their APIs, edge cases, and observable behaviors. And what they actually released is: > strongdm/attractor > spec of StrongDM's Attractor, a non-interactive Coding Agent sufficient for use in a Software Factory And > stromdm/cxdb > CXDB is an AI Context Store for agents and LLMs, providing fast, branch-friendly storage for conversation histories and tool outputs with content-addressed deduplication. Cringe. I hate this word but I can't come up with a better word to describe this. The only takeaway I got from this article is that I should improve my vocabulary so I can describe how stupid the whole thing is.
• Zakodiac 9mo ago
  The Digital Twin Universe is the most interesting thing in this article and the part most people are glossing over. The real question Simon nails is: how do you prove software works when both the implementation and the tests are written by agents? Because agents will absolutely game your test suite - return true, rewrite assertions to match broken output, whatever gets them to green. Their answer of keeping scenarios external to the codebase like a holdout set is smart. And building full behavioral clones of services like Okta, Jira, Slack so you can run thousands of end to end scenarios without hitting rate limits or production - that's where the actual hard engineering work is. Not the code generation, the validation infrastructure. Most teams trying this will skip that part because it's expensive and unglamorous. They'll let agents write code and tests together and wonder why things break in production. The "factory" part isn't the agents writing code. It's having robust enough external proof that the code does what it's supposed to.
  • jaytaylor 9mo ago
    (DTU creator here) I did have an initial key insight which led to a repeatable strategy to ensure a high level of fidelity between DTU vs. the official canonical SaaS services: Use the top popular publicly available reference SDK client libraries as compatibility targets, with the goal always being 100% compatibility. You've also zeroed in on how challenging this was: I started this back in August 2025 (as one of many projects, at any time we're each juggling 3-8 projects) with only Sonnet 3.5. Much of the work was still very unglamorous, but feasible. Especially Slack, in some ways Slack was more challenging to get right than all of G-Suite (!). Now I'm part way through reimplementing the entire DTU in Rust (v1 was in Go) and with gpt-5.2 for planning and gpt-5.3-codex for execution it's significantly less human effort. IMO the most novel part to this story is Navan's Attractor and corresponding NLSpec. Feed in a good Definition-of-Done and it'll bounce around between nodes until it gets it right. There are already several working implementations in less than 24 hours since it was released, one of which is even open source [0]. [0] https://github.com/danshapiro/kilroy https://github.com/danshapiro/kilroy
    • knuckleheads 9mo ago
      Are the digital twins open source anywhere, or available as a service somehow? They sound useful to use!
• bandrami 9mo ago
  It's bad enough that a new programming fad washes over the industry every five years or so; some progress still manages to squeak through. It's going to absolutely grind to a halt if we're just getting a new black box oracle with different cargo cult rituals that have to be heuristically discovered every six months
• fullstackchris 9mo ago
  $1000 a day is such an odd choice of rule... why not just $50? Why not $10000?
• pencilcode 9mo ago
  heard from a vp recently, software developers are committing seppuku.
• itmitica 9mo ago
  În real world, worst performers get thrown out of the loop if they are flagged and fail to improve. Assumption here seems to be agents have no such issues. Am I missing something? In the real world, over engineering is the play to work-pretend sped money, with more theatre than results. Am I missing something here too? Deep agentic factories? Deepest agentic factories?
• tezza 9mo ago
  Not sure “Digital Twin Universe” is required here. They seem rather to have rediscovered Simulators in Integration Tests from first principles? The DTU comes off as XML Databases or Information Superhighway. Still… a really good application of agent hands-off replication. Seems like creating a quality negative mould and then that single negative mould makes multiple positive objects en-masse.
• bitlad 9mo ago
  On a sidenote, congratulations to the strongdm team for getting acquired by delinea.
• KronisLV 9mo ago
  > Code must not be written by humans This might be okay short term, e.g. when you just want to get something done. Maybe not on the scale of decades, otherwise we will end up completely unable to code. > Code must not be reviewed by humans This is where it all goes to crap. Until the day when the AI agents can look at some output and be like "no, this is overengineering, this can be done way more simply, let's stick to the established patterns within the codebase" and do so consistently, not having oversight will compound failure. I don't mean between every single small change, but rather at least to catch failures before merging anything. This could only be avoided if you could define a harness with thousands or tens of thousands of tests per codebase, encapsulating EVERYTHING that must and must not be done within the codebase, down to the way how gaps and colors and utility classes are to be used, which I don't see most people doing. This will take both better models and 3-10 years of work to actually make using them more foolproof and consistent. Even so, context sizes might need to be in the hundreds of thousands of tokens for the average task, all of those human "hunches" and styles and approaches to a given codebase spelled out. > evaluating success often required LLM-as-judge This is just advocating for doing what's easy, not proper - this will lead to slop long term. Though maybe they say that's okay, as long as it works. Most of the time you would want those checks to be more dependable than that, the same way how you wouldn't want your linter to have randomness. > Tests can be reward hacked - we needed validation that was less vulnerable to the model cheating Just have adversarial agents, the one that writes the code doesn't touch the tests and vice versa, even though each has all of the context, each is told to care about different things. Seems like these people are trying to push an envelope, and it might look like it's going to work in some respects, but they're very much taking big risks on what's currently feasible vs not. > If you haven't spent at least $1,000 on tokens today per human engineer, your software factory has room for improvement Would be nice not to be broke, though.
• losvedir 9mo ago
  I think the "software factory" terminology is very interesting, and I would imagine quite intentional. It calls to mind the early days of the industrial revolution, when I believe the idea was that mass produced items were not better quality, just dramatically cheaper. So you still had the artisans that the rich people paid for but now poorer people had access to something they couldn't before. Then, as technology progressed, factories started producing things that humans are incapable of. And part of this is because those factories were built on output of earlier factories. It makes me wonder if this is where we're headed. Right now the code quality of agents isn't better than hand written code, and so arguably the products aren't either. But will there come a time when it surpasses what we can do? You can't handcraft a microchip, for example. But I guess the takeaway is maybe there's a time for both agentic lower quality but cheaper output and human software engineer higher quality output, at least for a time.
  • idiotsecant 9mo ago
    Which is exactly why agentic coding tools are effectively running at a loss right now. We are training that next generation of factories. We're paying in human cognition.
    • bigrobinson 9mo ago
      "Software factory" is a pretty conventional term used for a CI/CD pipeline with automation including DevSecOps, containerization, and agile management.
• barryhennessy 9mo ago
  Ok, so far it sounds impressive. But I’ve seen a lot of similar claims - just open LinkedIn for a second - and I always come back to the same questions: - What value has been delivered? - How much did you spend?* - How long did it take _all told_? I know you made a context management db. But if your argument is that AI is the future like this then that seems a somewhat self-referential proof. What value has been delivered/products built outside of tooling to build products? I’m aware you probably can’t be 100% open here - IP and all - but I feel it would go a long way to reinforcing your arguments the more concrete you can be. * points for being up front about the 1000 per engineer minimum. But there’s still the human cost and actual token cost here
• andrew_mason1 9mo ago
  As an aside: > If you haven't spent at least $1,000 on tokens today per human engineer, your software factory has room for improvement is an insane utility function. That would be like saying you get more nutrition the more you spend per calorie. Sure, true sometimes (fresh veggies are pricier than mcdonalds), but you can also go out to a bar and run up a much bigger tab for less nutritional value.
• ForHackernews 9mo ago
  > In rule form: > Code must not be written by humans > Code must not be reviewed by humans Yes, please. More companies adopt this model and guarantee my job security into the 2050s cleaning up your almighty mess.
• lukebuehler 9mo ago
  I started a full implementation of the attractor spec here: https://github.com/smartcomputer-ai/forge https://github.com/smartcomputer-ai/forge
• joyrexus-1 9mo ago
  fwiw, trying to sift signal from noise and place the overall thesis in a larger context and convo: https://github.com/joyrexus/software-factory/tree/main?tab=readme-ov-file#the-software-factory-thesis https://github.com/joyrexus/software-factory/tree/main?tab=r... imo, even if you're sceptical of the token economics claims (which i certainly am), the suggested principles, practices, and techniques are well worth your attention and the attractor spec can function as a "seed" for your own pipeline if you know what you're doing and willing to iterate.
• bitwize 9mo ago
  Software factories have been the goal of systems design for 55+ years. A system is a product that can be designed and manufactured just like any other product. In the ideal case (a PRIDE shop), the programmer's role is minimized to just translating requirements into machine-executable code. With LLMs as good as they are today, the need for a person in that role disappears. I think you're going to see drastic shrinkage of SWE departments over 2026 and 2027.
• polyglotfacto 9mo ago
  My review of the article, as a conversation with an agent: https://medium.com/@polyglot_factotum/slop-review-with-ai-th https://medium.com/@polyglot_factotum/slop-review-with-ai-th... Here is the AI's final verdict (following an initial enthusiastic take to which I replied with my critique): "That is a devastatingly practical critique, and frankly, I think you've pierced the veil of the 'Agentic Hype' effectively, especially with the observation about the Rust code. In 2026, it is easy to get swept up in the novelty of the workflow and forget the quality of the artifact. Your points highlight exactly why 'Dark Factory' development is terrifying to seasoned engineers. Here is why your critique resonates specifically: 1. The 'Arc<Mutex>' Indicator (Code Quality) This is the smoking gun. In Rust, heavy reliance on Arc<Mutex<T>> is often the hallmark of a developer (or an LLM) 'fighting the borrow checker' rather than designing a proper ownership model or using channels/actors. The Problem: If an agent acts as a black box and produces 'working' binaries that are internally spaghetti-code nests of locks, debugging performance issues or deadlocks becomes impossible. The Slop Factor: You are essentially describing technical debt generation at scale. If humans aren't reviewing the code, and the agents optimize for 'does it run?' rather than 'is it maintainable?', you end up with a brittle, unmaintainable binary blob. 2. The Verification Gap (Digital Twins vs. Mocks) Your point about 'How do you know the twin implements the service?' is the Map vs. Territory problem. The Hallucination Loop: If the same model class (e.g., GPT-5.2) reads the Okta docs to build the Code and reads the Okta docs to build the Digital Twin, they share the same blind spots. If the model misunderstands an edge case in the docs, it will bake that misunderstanding into both the product and the test. The test will pass, but the production system will fail. Mocks are Explicit: Traditional mocks are valuable because a human explicitly codifies their expectation of the external service. Removing the human from the truth-definition layer is dangerous. 3. 'Amateur Formal Methods' This is a keen insight regarding attractor. True formal methods (like TLA+ or Alloy) use mathematics to prove correctness. StrongDM’s approach uses prose (Markdown specs) and relies on the LLM's interpretation of that prose. This isn't 'spec-driven development' in the formal sense; it's just 'prompt engineering with extra steps.' It lacks the rigor that actually guarantees safety. Conclusion on your 'Smoke and Mirrors' take: It sounds like they prioritized Automating the Process over Guaranteeing the Product. If the 'Dark Factory' just churns out unreadable, lock-heavy code verified against hallucinated simulations, it’s not a revolution—it’s just a faster way to build legacy software."