To me, the thing that stands out about the whole state we're in here is PR review.

Yes, in an ideal world, PRs read well, are a joy to review, reflect what you discussed etc etc. We have to be real; there is only so much we can do to that end.

I'm not sure how the best teams do PR review, from my perspective it sucks. I'm talking specifically about the UX. I've always hated Github's PR page, so I typically reviewed by pulling down the branch and opening the diff with $EDITOR.

These days I think there's really no excuse for the awful UX. Linear (a company that isn't even in the domain of code review) put out a basic PR review feature[0] that is already better than what GH offers. It's simple: point a small model at the PR, group file changes together based on theme, add some commentary and sort by importance (schema changes > openapi spec).

Immediately, so much mental load has been reduced without the reviewer or the requester doing anything. This feature is pretty damn basic, and I think there are obvious next steps like generating visualisations which a dedicated product could find the time to implement.

Keen to hear others thoughts on why this is the wrong approach, or if there are tools in wide use that solve for this, or why this isnt the right problem to focus on.

0 - https://linear.app/docs/diffs#guides

• 4lx87

  today at 6:15 PM

  Gating integration behind code review is futile. I (and many other engineers) already automated it. My agent responds to review requests and reviews as me. Company policies enforcing human code review are futile.

  I think all these platforms chasing code review are doomed. My LLM doesn't need any of this tooling.

  We should be reviewing the actual working software. Systems that make it easy and instant to demo any proposed change are what is needed. Code (and specs) are going to fade into obscurity. PR review has already shifted towards validating the product (working software) over the process (code).

  The future of software production is more like Replit – not GitHub.

  • gabrieledarrigo

    today at 8:21 PM

    > Code (and specs) are going to fade into obscurity

    I'm always skeptical when I read absolute statements like this.

    Especially about specs. They drive and document how the software should work, behave, and under which conditions. In the same moment you write a prompt in natural language, you are writing a spec.

    Why should they disappear?

    For the same reasoning, we could no longer need books or manuals or documents (is it valuable to keep around that doc about F-22 specs?).

  • jeremyjh

    today at 8:28 PM

    This entire article is about the fact that the codebase deteriorates over time when you work this way. If they are correct, it will take longer and longer to develop PRs, and more and more cycles to QA them. Eventually the code will be unsalvageable and it might get there before anyone notices a problem. I don’t know if they are right but I know codebases can get there with humans at the helm - and the humans can adapt and learn.

    This is not a certain fate but it sure looks likely and is a serious risk. Some software is so low stakes that you can get away with it I’m sure - there are always trade offs.

  • layer8

    today at 8:18 PM

    > We should be reviewing the actual working software. Systems that make it easy and instant to demo any proposed change are what is needed.

    You’re arguing for experiment over logical proof or reasoning. That’s qualitatively a very different thing, and the former is no adequate replacement for the latter.

  • tripleee

    today at 6:21 PM

    What's your job as an "engineer" in this post-automated world?

    QA?

    • roncesvalles

      today at 7:41 PM

      The role of a software engineer is foremost about the ownership of software systems, and secondarily about modifying them or developing new ones.

      Software development is a continuous operational undertaking, like having a garden, and not a one-shot "task" like designing a logo. Systems need to be tended to and somebody needs to know how they work, especially if they're business-critical or (in the case of software companies), the business itself.

      A corollary point is that many of the rules and policies of the business are solely embedded within the software itself. There is rarely a complete set of documents that says "this is how everything works" -- if you want to know how something works, you ask a software engineer, they take a look inside the codebase and then tell you how it works. In that sense, all software engineers are also product managers (or more accurately, product managers are just crude software engineers, but that's besides the point).

      • jdzikowski

        today at 8:24 PM

        > The role of a software engineer is foremost about the ownership of software systems, and secondarily about modifying them or developing new ones.

        Yes! That's sooo accurate. Tools you use change, the level of abstraction you operate changes, but the role remains.

    • 4lx87

      today at 6:48 PM

      Producing features and fixing bugs, same as it was before. The organizational process of software development has not changed much with AI: execs decide direction and initiatives, PMs decide what to build, which is broken down into features and bug fixes that SWEs produce. In my experience organizations don't actually care how SWEs produce features, except insofar as it relates to how many and how fast the features can be pumped out. Organizations see code review as a process to prevent bugs. Humans are not as good as LLMs at reviewing code for bugs. Abstract notions of code style and quality that programmers care about is not why organizations enforce code review.

      • necovek

        today at 8:07 PM

        Before LLMs, "organizations" have seen code review as multiple things:

          * Share knowledge about a particular area of the codebase between multiple people
          * Share overall engineering knowledge between the parties in the review
          * Ensure maintainability of the codebase long-term
          * Ensure readability of the code
          * Catch architectural/directional omissions (yes, from the planning/architecture phase) before it's really too late and non-reversible change goes in (eg. large destructive DB schema change)
          * Ensure changes are small, self-contained, and as often as possible, reversible
          * Do some basic manual QA
          * Do comprehensive integration testing with a fully built-out system
          ...
          * And yes, catch bugs before they hit production.
        

        A lot of the above could be fun and engaging, and especially knowledge sharing and ensuring maintainability/readability was a very motivating thing for me as a more experienced engineer having learned so much from getting good reviews when I was less experienced.

        Programmers care about style to ensure readability and thus maintainability of the code, but also to keep changes minimal — if every diff converted between tabs and spaces in the entire codebase, it'd be impossible to see what has really changed with the simple tooling we generally use (one could build diffing tools that ignore changes like these, and they even exist, but are not ubiquitous).

  • 20k

    today at 6:24 PM

    >I (and many other engineers) already automated it. My agent responds to review requests and reviews as me. Company policies enforcing human code review are futile.

    This is also known as being a terrible engineer. If a company enforces human review and someone deliberately tries to circumvent this with an LLM, I'd fire that person in an instant

    The reason for human code review is:

    1. So *you* understand what's going on, not the LLM, and people can ask you questions about it

    2. Because LLMs are not that good at code review

    It seems weird to brag about literally not doing your job. It sounds like you could be replaced with a python script, what value do you bring?

    • dhorthy

      today at 6:46 PM

      blake smith has a really good post on this - that mental alignment among the team is the primary purpose of code review - https://blakesmith.me/2015/02/09/code-review-essentials-for-...

      • 4lx87

        today at 7:05 PM

        That is a good post. Thank you for sharing.

        I can't help but notice that this person is speaking as a programmer, not the person in charge of employing programmers. Is that what the business values code review for? In my experience, managers enforce code review as a quality control mechanism: the "Find Bugs" step in the article's pyramid. And LLMs are already better than human reviewers at the "Find Bugs" part. Design and alignment with PMs and sales can happen before and after software delivery. At least that's how my employer sees it (and I suspect most other businesses).

        It's a rough time to be a programmer who cares about the code, who understands software is a creative process, who understands that designing the software is intertwined with the code, who cares about systems. The hyper-focus on delivery was already a lot to deal with before LLMs.

        • DaiPlusPlus

          today at 8:28 PM

          > In my experience, managers enforce code review as a quality control mechanism: the "Find Bugs" step in the article's pyramid.

          Nope.

          To reduce it down to a single word, I'd say we do code-reviews to assess "taste".

          -----

          Code-review is one part of a larger process (the SDLC!), and while review does help with "finding bugs" it is not the singular reason why we do it; and other parts of the SDLC are concerned with finding bugs in the first place, namely the various Test and QA steps in the process; when your code is in the (peer) code-review step then there's an expectation that the author already identified and resolved actual bugs/defects (i.e. where actual-program-behaviour deviates from the spec[1]), so a PR for new functionality is expected to include unit and integration tests to demonstrate that.

          Now Claude will gladly take a Jira ticket, write-up a plan/spec, write tests, implement the feature, verify the tests pass, address static-analysis issues, push branch, and submit the PR - and if-the-program-works then it's "correct" and so surely there's nothing really to review and so merging the changes should be a breeze... but I find myself rejecting these PRs all the time because these agents still "just don't get it"[2]. (But I'm sure they'll "get it" eventually; you can't stop progress). We can revisit this topic when we get there; but for now I'm going to reject an AI-authored PR that eschews it.

          Good taste is important.

          [1] I'm not going to pretend anyone actually writes any kind of spec (informal or otherwise) for the vast majority of software out there; but an unwritten-spec exists when you mentally combine a vague Jira ticket, platform-conventions and common-sense (and that's how Claude in an Agentic Loop works too, except it always has to write-out the Spec.md/Plan.md to disk first, whereas us humans keep things in our head).

          [2] I cannot define "it".

    • amannm

      today at 6:46 PM

      It seems weird to get angry about a change that is happening and will continue to happen due to what the market demands from software, which I believe will be the speed/ability to solve problems, rather than its own stewardship

      • computably

        today at 7:55 PM

        Sure, if you're shipping a 500MB mobile/web app with a 5s start-up, it probably won't make a difference today, or tomorrow, or 3 months later. The problem is when your codebase is a dumping ground for AI slop and a year from now nobody can make any changes.

        Also, it's not just some subjective value put in human review. If a change causes a major outage and it turns out it's because 5 reviewers were all shirking the company-mandated responsibility of review, and it could trivially have been caught, I would 100% expect those people to get fired. It's not a process issue if people are intentionally circumventing the process.

    • 0xblacklight

      today at 7:18 PM

      this is exactly right

  • jfkfisksnsb

    today at 6:29 PM

    [dead]

• tcoff91

  today at 6:21 PM

  PRs sucked to review long before Agents were a thing, but now it really sucks because there are more to review.

• xorcist

  today at 6:04 PM

  > group file changes together based on theme, add some commentary

  Isn't that what commits are? Or ... should be?

  • lozenge

    today at 8:11 PM

    No, commits always display the files in a fixed order, and then display changes from line 1 to line N. An AI could select the order to display in, add per hunk commentary and automatically adjust how much context lines are displayed.

• boron1006

  today at 6:28 PM

  I just dont think LLMs are very good at judging importance or summarizing code.

  I tried experimenting with what is ultimately a treesitter based approach - https://github.com/0x007BA7/codebook

  And really liked it. Definitely nowhere near production ready but I think theres room for a player to come in and do something similar.

  • dhorthy

    today at 6:45 PM

    yeah that was another thing i hoped would pour through here - that deterministic systems are much better for evaluating quality (test, linters, cyclomatic complexity, etc) - but that we don't have such a system for code maintainability, at least not one that's widely accepted or adopted

• 2001zhaozhao

  today at 6:09 PM

  I think the right shape is to review and merge directly from the agent window.

  • 0xblacklight

    today at 7:19 PM

    reviewing code as it's being written & re-steering it > reviewing it once 20k lines have been written

    • 2001zhaozhao

      today at 8:29 PM

      Yep i aim to split my work into tickets that are <=1k lines of code each. In the end it all gets squashed into a mega 10k commit regardless but i can keep track of the quality much more that way.

      (more precisely the sub-tickets merge into a bigger feature branch, which in turn gets squash merged into the main branch at the end. i have a tool that automates this flow with a gui and ticket management.)

• claytonjy

  today at 7:20 PM

  thanks for pointing out the linear PR stuff, hadn’t seen that. Interesting that while a dozen other companies are trying to muscle in on the hosting/versioning side of github, rather fewer are working on the PR side.

• WorldMaker

  today at 6:31 PM

  > I'm not sure how the best teams do PR review, from my perspective it sucks. I'm talking specifically about the UX. I've always hated Github's PR page, so I typically reviewed by pulling down the branch and opening the diff with $EDITOR.

  When $EDITOR = VSCode there's a shortcut on the GitHub PR page: if you type a . it opens in github.dev in a VSCode instance.

There's some good ideas and points in here, but this bit threw me:

> # We tried this > In July 2025 we went full lights-off

Isn't it pretty well-accepted at this point that the models underwent a step-change in usefulness around fall 2025 / spring 2026? I know that I was able to start handing agents whole features after that, but not before.

I feel like any perspective/experience on "what agents can/can't do" from before that period is... maybe less than relevant to the modern era. TFA calls it out a few sections later with "But surely the models have gotten better since then", but then just writes off any improvement. That does not match my experience.

• tcoff91

  today at 6:21 PM

  Opus 4.5 was a massive step change in capability for sure. The opinions of anyone who hasn't bothered experimenting with these things post-Opus-4.5 are not worth a damn.

  They still are far from perfect but they're massively helpful.

  • json_hero

    today at 6:56 PM

    read. https://github.com/humanlayer/advanced-context-engineering-f...

  • today at 6:56 PM

• 2001zhaozhao

  today at 6:14 PM

  I had a bit of this impression when reading the post as well as the authors' product website. A lot of it does seem to be stuck in 2025.

  For instance I think their post "long-context isn't the answer" on their website post straight-up isn't accurate, and gives me the impression they are just extrapolating previous performance to new models. In my experience, Opus 4.6 and newer have worked very reliably for long context to me (i don't perceive any intelligence drop at 700-900K tokens). Yeah it's extremely cost-inefficient, but it works.

  • hansvm

    today at 8:07 PM

    FWIW, I notice the intelligence drop drastically with long contexts with Opus 4.6. It's barely usable for anything intricate and long. That long window is good for _something_, but it's not as good as a short window.

  • today at 6:37 PM

• dhorthy

  today at 6:25 PM

  my perhaps controversial take is that opus 4.1 was smarter than 4.5 for complex engineering work, but 4.5 was faster and "squishier" - it responded better to simpler prompts, it read between the lines of user input better, and that this was really important to converting new users quickly

• json_hero

  today at 6:55 PM

  Did you even read further on? The section right after that addresses the step changes in current frontier models https://github.com/humanlayer/advanced-context-engineering-f...

  • fishtoaster

    today at 8:33 PM

    As I mentioned explicitly in the comment you're replying to: yes, I did read that section. Did you not bother to read my whole comment before telling me to read more?

  • dhorthy

    today at 7:46 PM

    it is absolutely wild to me that this keeps floating to top comment thread when the guy very clearly did not read even the first half

It is comforting to find other people experiencing the exact same reality as me, since I see so much in this post that matches my own experience.

It reminds me of all the recent talk about "taste". Architecture "quality" may not be objective in a right/wrong sense, in the same way that fashion isn't right/wrong. It's like we are all going to have to relinquish reason/rationality to the machine and start to study up on aesthetics.

Even historically, my big struggles have usually been deciding between two nearly-equivalent options. I get this a lot now with LLMs because there is no break in-between these decisions that implementation used to force. I feel I'm constantly making "taste" calls between tradeoffs that have no clear objective criteria, and it is as exhausting as the code review this post (and my experience) suggests are still necessary, even with Fable/GPT-5.6 level models.

In many cases, I do what I've done with junior engineers whose code I reviewed pre-agent: make on-the-spot judgement calls. When I see a broken window, I call it out. But when I see minor issues, I sometimes just let it pass, note it in memory and tackle it wholesale once an accumulation of similar minor issues get to a certain size.

As a tangential aside, I consider two dev shops from pre-agent days. One decides to hire 7 extremely talented engineers and gets them to work closely together. The other decides to outsource to 100 decent engineers and tries to silo them into modules. I think we are facing a similar choice with agents. You can either work extremely closely with a handful of agents, collaborating on design, review, etc. Or you can spin up a fleet of sub-agents and YOLO, then try to separate the wheat from the chaff in some automated way. My taste is the former, small highly coordinated shop. But time will tell if I am right or wrong.

• dhorthy

  today at 8:35 PM

  yeah my best articulation of taste is something i got from Jake Nations[1] while he was still at netflix -

  "you know a bad pattern when you see it because at some point you were up at 2am debugging it"

  taste is the hard-earned intuition about every anti-pattern and landmine that has blown up in your face since you started doing software

  1 - https://www.youtube.com/watch?v=eIoohUmYpGI

I think there is a fundamental issue here of what building software even means

If you think you can just assign Github tickets to AI agents and go drink daiquiris on the beach I think you'll find that you end up with more and more towers of abstraction and indirection. There are 'points of view' that emerge during coding I think. And at some point you as a human have to be like "wait... what if we use Redis here". "Wait.. the API is already returning the data we need". "Wait... let's not add customers to the report who have not been active in the past year". Stuff like that

• claytonjy

  today at 7:26 PM

  > There are 'points of view' that emerge during coding

  I know it’s a bit cliche at this point, but this harkens to “programming as theory building”[0] which I agree is easy to lose out on when embracing agentic coding today.

  [0]: https://gwern.net/doc/cs/algorithm/1985-naur.pdf

  • dhorthy

    today at 7:31 PM

    I have had the phrase "programming is building a theory" spinning in my head for days, especially since watching this pragmatic engineer pod with Kent Beck https://www.youtube.com/watch?v=ddHQQtjIOpw

• dhorthy

  today at 6:39 PM

  yeah I 100% agree - and I think the most popular coding agent workflows / skill kits are designed to pull those insights and intuition out of humans in a way that optimizes for the developer's experience building the plans or building the code, e.g.

  - claude code plan mode - mattpocock/skills - obra/superpowers - research/plan/implement

  etc etc

  • piker

    today at 7:00 PM

    Hard to see them though if you’re not in the weeds and your agents are stacking abstraction on abstraction to pass tests.

    • dhorthy

      today at 7:01 PM

      yes exactly

• AmericanOP

  today at 7:23 PM

  The machine gives you what you ask for even when that thing doesn’t exist yet.

  Rather than “lights off,” utilizing information theory, decision-making theory and creativity theory makes me better at asking for the right things.

  Memory is not transcribed to weights like when humans sleep. Memory is notes handed to someone on groundhog’s day who can’t remember yesterday. We hope they believe us. Don’t be too surprised when a highly entropic system introduces entropy to a project over time.

I'm currently learning about Cost functions and Regression in the Machine learning course on coursera[1], and I cannot help but be struck by the similarities of how gradient descent seeks to minimize the error between the model and the training data, how agents do the same (far less mathematically) to seek an acceptable solution to software problems, and how light evolutionary pressures seem to guide species towards a better fit solution to the problem of existence and reproduction. (I'm no expert on the evolutionary example so go easy on me!)

[1] - this course: https://www.coursera.org/learn/machine-learning/home/welcome

> So, why can't models do software maintainability?

I feel like the explanation does nothing to actually elucidate why models can't do it. Is it an inherent weakness of LLMs? Training processes? The typical "this is crap" that we constantly hear? It goes on to write about RL and how there's no penalty for bad design. But that sort of side-steps the question and makes you ask: "why not do RL and make a penalty for bad design?" Of course the models aren't good at it ... they're not good at anything until you've tuned them and put them in a harness that rewards good edits and throws away (improves) bad edits. That doesn't explain why "models can't do software maintainability." The real question is why harnesses can't do software maintainability, and how to build a system that can do it. (I suppose that's the purpose of the ad at the bottom of the page.)

• jdlshore

  today at 7:47 PM

  I think it’s because maintainability is a factor of software design, and good design is squishy and hard to articulate. There’s no good metrics for design. All the tools that purport to measure it are doing trivial things like cyclomatic complexity, and can only tell you when things have gotten really really bad, but not distinguish between “good” and “pretty bad.”

  Design skills take about 10 years to develop, in my experience, and a lot of smart engineers go through a phase where they make gawdawful messes in the name of “magically easy” designs around the 5 year mark.

  Design requires wisdom born of experience, isn’t measurable, and requires forming a mental model of how the system hangs together as a whole. It’s just not stuff LLMs are good at.

  • jadar

    today at 8:10 PM

    > It’s just not stuff LLMs are good at.

    But then you're back at the question from the OP of "why not?" Is it lack of good examples in the training data? Is there something of code "goodness" that goes beyond phenomenon that are measurable? Is it that LLMs lack in the ability to organize and think abstractly?

• Fordec

  today at 6:59 PM

  I have a hunch it comes down to the training data. We have spent decades as an industry talking up the new shiny thing, deliverables, frameworks, features, performance improvements, the one thing you don't read copious amounts of prose about is "how I maintained our system so that nobody noticed".

• dhorthy

  today at 6:43 PM

  fair point, this is the thing I struggled most to extract out while writing it - if you can propose an RL environment that penalizes a model for bad design, then I'm all ears - right now there's no fast oracle/verifier for this (as stated in the post)

  My current evolving take on "how would you build such a thing" is you need to tee up a roadmap of 20 features and feed them to a model one at a time, so it can't design up front for what's coming.

  That way if it builds the first 10 features and the codebase goes to slop, it get's penalized when it can't build features 11-20, or when those features take wayyy more tokens/time/cycles than a model that maintains a clean codebase can do.

  This is how most real software is built by most teams - incrementally, getting feedback from users along the way, and steering goals in response.

  • jadar

    today at 7:47 PM

    Isn't that how AI written software gets better too? By steering the model towards the goals of the user?

    I don't know if it's a question of how many features to feed to the model, either. Of course, overwhelm the context with too many features and it will get confused. But that's where the memory management idea that G. Huntley talks about is helpful. You're trying to steer the model within its memory limits towards a certain goal.

    The problem is getting it to produce "good" code. Formalizing what that means is the task of the programmer. How do you steer a model towards always, or more often, producing good code so that you don't have to do rework? That's the same problem as with a junior engineer, but the way you do it is different. Right now we're trying to do it with mountains of prompts — which sort of works but has diminishing returns — and with onerous code reviews. We've seen this get better over time, but I think some more mechanical methods will help as we figure out how best to steer the models.

This is one of the best writeups I've seen of this

a lot of the model's constraints come down to how they are RLed. Discussions online would be a lot better if everyone understood how the labs train the models in a high level (or did a lil data labeling)

• dhorthy

  today at 6:47 PM

  yeah i like this and others in the thread mentioned that understanding RL and RLHF and the shape of the data is really important (at least the fundamentals, I'm sure there's quite complex industrialization of RL inside labs as Nathan Lambert says)

>It's easy to be a little bummed by the core thesis here: "for now we're stuck reading the code".

>I was pretty excited for a world where we could just ask for things and let the models cook and not read the code and get beautiful production software

I feel so disconnected reading those things. Reading and writing code is what brings me joy. I'd never feel "bummed" or "stuck" with it.

I've recently started experimenting with grounding LLM driven implementation/verification on RFC based normative specifications, to avoid having to manually steer the LLM during implementation and dealing with reviewing sloppy pull requests.

It works quite well, as it puts your entire focus on writing (hopefully) unambiguous specifications vs. having to discuss unwanted changes with an LLM during code-review. One flaw is that this only works great if you know exactly what you want, which is not always the case.

• boredtofears

  today at 8:35 PM

  I'm curious how that works - are you actually hand writing specs with RFC level detail yourself completely or is it more of an LLM assisted effort? It seems like writing a comprehensive spec manually would almost be as much (if not more) work than the implementation.

• Lindby

  today at 6:40 PM

  But do you actually gain anything if you need to write detailed specifications? That seems just as time consuming as writing code, but less gratifying.

  Code is just detailed specifications on how things should operate.

  • Balooga

    today at 8:07 PM

    > Code is just detailed specifications on how things should operate.

    The spec defines how things should operate. Code defines how things operate.

    The problem being that if there is only code, then any change to system behaviour is always correct (including bugs). Because that's what the code says.

    Relying on tests won't help without a spec to create tests from. So tests are generated from code. So if a test fails, it's the fault of the test, not the code.

  • mrbnprck

    today at 6:57 PM

    Yes, actually that's what I'd had argued a few years ago as well.

    It turns out that there are now a few more people that want to get their hands on building software, that don't necessarily understand code, but do have a fundamental idea of system design / requirements.

    As you said code has always been a much more explicit representation of those specs, yet arguably introduces lots of noise, necessary to make the program compilable.

    Us devs already had the obligation of writing technical documentation for non-technical people, just not at an explicit depth. From an efficiency PoV making that documentation more explicit is much cheaper than manually writing the compilable code. Hurts to say but AI got pretty good with the latter.

• dhorthy

  today at 6:34 PM

  normative specifications can help, but the thesis here is that specs that define behavior of the product or even architecture are helpful but there's MORE that can be done and even though "program design" feels too in the weeds it's still essential if you care about maintainability

  • mrbnprck

    today at 7:17 PM

    Isn't maintainability mostly about applying basic engineering principles e.g. separation of concerns, single responsibility, dependency inversion, open-closed etc..? If these topics are addressed in the normative representation, and correctly translated by an LLM into code (especially by slicing up the specifications into measurable outcomes to set the intended foundation), then future change e.g. maintainability becomes essentially easy as well, no?

    Historically I know that the majority maintenance problems occur from slow continuous evolution of a system that it initially was never designed for. And the only way to address this was continuous system design.

    • dhorthy

      today at 7:22 PM

      > Historically I know that the majority maintenance problems occur from slow continuous evolution of a system that it initially was never designed for. And the only way to address this was continuous system design.

      yes exactly - this is what I'm advocating for - that you can't skip the system design, and that actually good system design goes down to the typedefs and object graph at the code level, not just mermaid charts and db schemas and service contracts.

      I will highlight what a few others have said along the lines of "a sufficiently detailed spec IS code" - that is, to make the spec guaranteed to produce the code you want, the spec will look a lot like code (and will be roughly the same effort to review as the code itself anyway, saving you no time)

      what I'm proposing is "how can you maximized the odds that the code WILL be good or close enough to good that its easy to get there, with the LEAST amount of human effort/attention" - how can you move fast without skipping what matters

      https://haskellforall.com/2026/03/a-sufficiently-detailed-sp...

Enjoyed most of this but unconvinced by the program design part. If I see an agent writing function signatures or listing which functions to edit in a plan that tells me that I’ve given it too big a vertical slice. I always delete the code guesses. The thing that writes the code must always spend some time discovering where/what to write or it won’t have the right context. Or put another way: “decide first, act later” always feels worse than act-learn-act.

• dhorthy

  today at 7:42 PM

  one thing I probably didn't mention is we do the program design having already done an in-depth codebase research, with current patterns and architecture surfaced - that actually seeds every step of the flow including even the product part -

  but yes if you're working in very small slices then I think it's very feasible to skip program design and just review the code as you go, and resteer live. I do this all the time for tasks that are too big for a oneshot but on the smaller side overall.

> When I say maintainability, I mean the specific thing where it becomes really, really hard to change one part of the codebase without breaking another part.

The corollary of agents being bad at maintainability but good at coding is that you can vibecode all the parts where maintainability doesn't matter.

So if you build a (domain-specific) modular architecture for your software first you can then just let your software factories loose on building the modules.

• layer8

  today at 8:29 PM

  Except that there is typically a feedback loop between the implementation and the module interfaces. While implementing, you discover aspect that makes you adjust, and sometimes completely alter, the interfaces and module boundaries. And that’s not just for an initial implementation, it continues to happen as new requirements come in over the lifetime of the software. Ostensible implementation details continue to inform the architecture.

• throwatdem12311

  today at 6:59 PM

  Until you inevitably need a cross cutting concern.

  “Oh just this one time”

  Then an agent sees the pattern and assumes it’s a best practice. Then your beautiful architecture is ruined.

  “Just this once” indeed.

  • dhorthy

    today at 7:10 PM

    this is 100% right. you have to guard the codebase patterns with your life. because the codebase is part of the prompt.

• dhorthy

  today at 6:27 PM

  yeah this is along the lines of what some friends of mine call "core vs. pragmatic modules" or even s/modules/codebase zones/

  the idea that if you have a solid core and decoupled modules, you can have "zones" in your codebase where you allow the model to run wild and do a little slop, because you know the blast radius is contained

My radical opinion is that LLMs are harmful for software development - they are the ultimate "goto" operator. All actual code should be written by a human developer.

Instead, use them in adversarial mode - run QA scenarios using LLM agent as a substitute for end user to do bug discovery.

• arm32

  today at 7:10 PM

  I love how we need to preface such an opinion as being "radical" nowadays.

• 0xblacklight

  today at 7:16 PM

  why?

I 100% whole heartily agree with this. Anyone saying the models made a huge leap in fall 2025 / spring 2026 still aren't looking at whats going on. Just this weekend I thought I had a solid plan and evals/tests to let 5.6 sol work unsupervised over night while I slept and it made an absolute mess. Somewhere in the loop it had to make a decision and it made a wrong one. Making everything beyond that trash. The code 'worked' but it had the wrong system design and wrote the most brittle tests around its assumption, validating its own decision. It turned into a nasty feedback loop for the model. This is 5.6 sol high.

The models write good/great code. I'm very happy to never write code again but models are no where near good enough to run off on their own without a human in the loop. Models LOVE to cheat. Just peek at the tests they write.

And before you come at me, I have built 7 products in the past 1.5/2 years with agentic engineering, all with users. One of those projects is _dead_ because I let the vibe go too hard at the same time Anthropic decided to nerf both their harness and their models silently. If you care to look at the source: https://github.com/Robdel12/OrbitDock I spent a week or so and like a billion+ tokens trying to refactor and save it. It just wasn't worth it.

I wish people would be pragmatic about this. I get the dream is to let it do everything and not to be in the loop, because being in the loop is exhausting. But if you want to make whatever you're building be robust and survive more than 6 months, you have to. I don't care how good your tests, plans, skills, etc are. At some point the model will have to decide something and it'll be the wrong one. Compounding the slop from there forward.

• dhorthy

  today at 7:44 PM

  > I spent a week or so and like a billion+ tokens trying to refactor and save it. It just wasn't worth it.

  this is exactly what happened to github.com/humanlayer/humanlayer - it was overslopped and we reset from scratch to build it right - spent 2 weeks in VS CODE - not even cursor, plumbing the core patterns from scratch. codebase is part of the prompt, yada yada

  > I wish people would be pragmatic about this

  that might be the tl;dr for the whole post haha

Necessarily, better data is what we need, more importantly, better collaboration and better specialization at all. While the title is a bit misleading and clickbait-y, the message is decent.

I disagree with the way that big models are trained on noisy relationships and RL is applied to tone it back down, it represents a stupid amount of compute thrown at this problem at a scale that is often unnecessary.

The rest of it is on point.

This is a very well written article and he makes his arguments backed up by data.

We may choose to disagree but thats the point of healthy debate based on clearly expressed opinions.

Key point is I don't think this is AI slop which is way too common in long form articles these days and in keeping with the whole point of his article.

Wait these arent “software factories” they are strung together ai rube goldburg machines

Its crazy to me people write these articles and create standards like this is some kind of engineering standard with years of research and experience

This is like calling these folks the experts on aviation: https://youtu.be/M9Yww9LG3gw?is=xgtA-xMpNy-09Asu

Its still so early in the game for de facto standards - engineering teams need to experiment and see what works for their own quality metrics not just parrot “standards and methodologies”

This is still the very early days of AI and AI engineering

• dhorthy

  today at 6:29 PM

  interesting - i'd say my main goal is to put the current "agentic software factory" hype in the historical context of "we've actually been rube-goldberging software deploys for a while now"

The dude is selling an IDE.

Also it's missing the point of a software factory concept

A software factory will not work infinitely forever for everything. A software factory isn't a solve anything button (aka god).

In a conventional factory, things break and fail. Process machines get poluted. Extruders get jammed.

You still need to establish intent, define what you care about, define guardrails, and of course manage the factory.

• dhorthy

  today at 7:39 PM

  and build it incrementally!

  You don't have to build the entire software factory at once. You don't have to mastermind the whole future system, instead you're actually stacking and layering these small, isolated problems.

  I think that's a really good approach to start getting value tomorrow or this week without saying, "I'm going to revolutionize how we ship."

  It's just:

  1. Find places where you can use agents.

  2. Figure out where the right leverage points are for humans and where the right leverage points are for agents.

  3. Just start building those things and plugging them into each other.

  One day you'll wake up, and 80% of all of your stuff is automated.

  • rapatel0

    today at 8:18 PM

    Totally. Also to add to that. I think (like any factory) you need to build in systems to allow you to have observe and service the machines make process changes as needed.

    You're the foreman/factory manager. You can optimize the factory over time upgrade machines, place machines closer or add conveyor belts for more productivity.

    The only think that slightly worries me is that the Labs are clearly incorporating the best in class logic from their datasets.

Personal anecdote: I was able to set things up in such a way that multiple non technical people at my job were able to build features into our project. One person even created our own CRM. And I'm not a turbo-genius savant.

The one downside was that it required their computers to install dev dependencies, postgres, infisical for secret management, etc.

That's the next frontier. What I'm working on now independently. I plan to open source this solution, but again I'm not a savant genius. I guarantee many people are working on the same thing it's converging. Our job as engineers is becoming more of a higher level facilitator and AI "plumbing" maintenance work. How can we get the AI to empower everybody at the company while keeping the wheels turning. That's my aim.

> I haven't been able to dig up any definitive data/findings from StrongDM on how that whole dark factory went. The weather-report has a few sparse updates between February and June of this year.

This was easy to find out I thought. And just with an old-fashioned google search too, no deep research agent needed. See here: https://diffusion.io/

Seems like it went pretty well if a consulting company is now being started.

I agree with a lot of what Dex Horthy is saying here but on some fronts I feel like he's missing something. Coding well with LLMs, it's not a skill issue, it's an effort/laziness/rigor issue.

In order for coding with LLMs to go well, there has to be more rigor, more discipline, more good engineering hard-assedness. To reiterate, the teams seeing the best results with AI were already high-discipline and high-hygiene.

AI works on data. The better the data, the better the likelihood of a desirable outcome. Code is data. If you have bad code, no matter how awesome the model you let loose on it, you can't get as good a result as if you had good code to start with. This principle has been well known in AI/ML circles since the 20th century.

e.g., if you are doing spec driven development and not seriously investigating formal verification, IMHO you will come up short. Prompts are simply not enough to steer a coding agent to the level of precision needed. Without deep programmatic verification - at all levels, formal verification is just one slice - the solutions the agent produces will always be just slightly (or very) out of true.

• jaytaylor

  today at 7:12 PM

  Hi, I'm one of the trio from the StrongDM AI Lab.

  Just a minor thing I want to clarify about the Weather Report [1] - it's framed in kind of a negative light in the article ("sparse updates"), but we've been updating it as frequently as we find a meaningful improvement in a relevant dimension. Since we launched it in February it has averaged about one update per month, as frontier labs keep racing forward!

  [1] https://factory.strongdm.ai/weather-report

  • dhorthy

    today at 7:14 PM

    appreciate that context! I definitely did not mean to come out and say "its definitely not working" or anything, but would love to hear from y'all a retrospective on the ~5-6 month anniversary - what was right, what did we get wrong, etc

    • jaytaylor

      today at 7:38 PM

      We are working on new articles to share our latest findings, so stay tuned! Overall our outlook continues to be bullish. Almost all software problems yield to a combination of the Factory Techniques covered on the strongdm.ai website. More powerful models work even better...

      • dhorthy

        today at 8:41 PM

        awesome - i have updated the post with a link to this thread!

• edot

  today at 5:47 PM

  “Seems like it went pretty well if a consulting company is now being started.”

  You interpreted this backwards. Software companies offer consulting when their product cannot stand on its own. See Palantir, Salesforce, etc.

  They are successful companies, yes, but not successful products. The product needs to be instantiated and maintained by sales engineers and consultants and customized into something so bespoke that it’s hardly the company’s product anymore.

• today at 7:10 PM

• stellar_jay

  today at 5:52 PM

  > Prompts are simply not enough to steer a coding agent to the level of precision needed. Without deep programmatic verification - at all levels, formal verification is just one slice - the solutions the agent produces will always be just slightly (or very) out of true.

  I found this to be exactly right, and in my work I’ve come up with a taxonomy of constraint mechanisms which I keep in mind when guiding agents: generative to constrain the output of the model, interpretive to constrain how the model ‘understands’ code, and elicitative to help it ask the right questions of users.

  Full write up is here: https://www.research.autodesk.com/blog/constrain-agent-not-u...

  • _doctor_love

    today at 6:29 PM

    That's an excellent writeup. Haven't gotten all the way through it yet but so far I'm with you.

• sythe2o0

  today at 5:59 PM

  Some more context on the consulting company: StrongDM was sold earlier this year, about a year after the dark factory was first announced, and the former CTO moved on to this (presumably) in order to continue the idea.

  Disclaimer: I'm a former StrongDM employee

  • navanchauhan

    today at 7:12 PM

    apg?

• dhorthy

  today at 7:06 PM

  > In order for coding with LLMs to go well, there has to be more rigor, more discipline, more good engineering hard-assedness. To reiterate, the teams seeing the best results with AI were already high-discipline and high-hygiene.

  hard agree. But i don't think this is sufficient. Even formal verification has its limitations.

  > AI works on data. The better the data, the better the likelihood of a desirable outcome. Code is data. If you have bad code, no matter how awesome the model you let loose on it, you can't get as good a result as if you had good code to start with. This principle has been well known in AI/ML circles since the 20th century.

  hard agree. but also RL data is shaped differently than SFT data that has driven the majority of AI/ML innovations since ~2000, and its where there's so much room for innovation still. e.g. ImageNet was all just hand-labeled answer pairs.

  > it's not a skill issue, it's an effort/laziness/rigor issue

  I'm sorry but this feels like a semantic argument - the point of "skill issue" is "you didn't put in the effort or learn the techniques"

Dex you aren't part of the slop cannon, you _are_ the slop cannon

• molsongolden

  today at 8:06 PM

  Just in case this isn't a compliment, I'll note that I think Dex has been pretty good about admitting when they were wrong, explaining why they were wrong, and what they're doing now instead.

  • dhorthy

    today at 8:11 PM

    we out here trying

• dhorthy

  today at 6:48 PM

  i can't tell if this is a compliment or not

[dead]

[flagged]

• dang

  today at 6:09 PM

  "Please don't post shallow dismissals, especially of other people's work. A good critical comment teaches us something."

  https://news.ycombinator.com/newsguidelines.html

  (and please particularly avoid personal attacks on this site)