4 ms·

I’ll go against the prevailing wisdom and bet that clean code does not matter any more. No more than the exact order of items being placed in main memory matte

• iterateoften 7mo ago
  Garbage in, garbage out. The llm is forced to eat its own output. If the output is garbage, its inputs will be garbage in future passes. How code is structured makes the llm implement new features in different ways.
  • aspenmartin 7mo ago
    Why would “messy” code be garbage? Also LLMs do a great job even today at assessing what code is trying to do and/or asking you for more context. I think the article is well balanced though: it’s probably worth it for the next few months to try to help the agent out a bit with code quality and high level guidance on coding practices. But as OP says this is clearly temporary.
    • iterateoften 7mo ago
      The definitions of what is messy or clean will change will llms… But there will always be a spectrum of structures that are better for the llm to code with, and coding with less optimal patterns will have negative feedback effects as the loop goes on.
      • aspenmartin 7mo ago
        I agree with you but you can dedicate tokens to fixing the bad code that agents do today. I don’t disagree with anything you’re saying. I think the practical implication is instead of pain and jira we’ll just have dedicated audit and refactor token budgets.
    • SpicyLemonZest 7mo ago
      I'm dealing with a situation right now where a critical mass of "messy" code means that nobody, human or LLM, can understand what it is trying to do or how a straightforward user-specified update should be applied to the underlying domain objects. Multiple proposed semantics have failed so far.
      • tracker1 7mo ago
        On the plus side.. AI is pretty good at creating (often excessive) tests around a given codebase in order to (re)implement the utility using different backends or structures. The one thing to look out for is that the agent does NOT try to change a failing test, where the test is valid, but the code isn't.
• DarkNova6 7mo ago
  That works until you have to fix a bug
  • aspenmartin 7mo ago
    Why does having a big break this? You can have the LLM guide you through the code, write diagnostics, audit, etc.
    • DarkNova6 7mo ago
      And what's the certainty of this fix no introducing another bug? Then you realize tests are failing but now you are not sure if they actually test against implementation or if they were genuinely good tests. It's a slippery slope that adds more and more cruft over time and LLMs are susceptible to missing important details.
      • aspenmartin 7mo ago
        No certainty just like we don’t have certainty when we do it ourselves. What I’m saying is you can audit and use the LLM to help you audit efficiently: finding code, explaining logic, visualizing things etc. it’s just as powerful a tool for understanding as it is for generation
• charlieflowers 7mo ago
  It is an interesting possibility that must be considered. Only time will tell. However I disagree. I think complex systems will still turn into a big ball of mud and AI agents will get just as bogged down as humans when dealing with it. And even though re-build from scratch is cheaper than ever, it can't possibly be done cheaply while also remembering the millions+ of specific characteristics that users will have come to rely on. Maybe if you pushed spec-driven development to the absolute extreme, but i don't think pushing it that far is easy/cheap. Just as the effort to go from 90% unit test coverage to 100% is hard and possibly not worth it, I expect a similar barrier around extreme spec-driven. Clarification: I'm advocating clean code in the generic sense, not Uncle Bob's definition.
  • fooker 7mo ago
    In my experience large scale automated refactoring of code is something that works reliably for the last 3-4 months.
    • charlieflowers 7mo ago
      But if you are saying that a human can instruct ai agents to refactor to prevent the big ball of mud, then you are saying that clean code *is* important.
• namar0x0309 7mo ago
  You haven't worked or serviced any engineering systems, I can tell. There are fundamental truths about complex systems that go beyond "coding". Patterns can be experienced in nature where engineering principals and "prevailing wisdom" are truer than ever. I suggest you take some time to study systems that are powering critical infrastructure. You'll see and read about grizzled veterans that keep them alive. And how they are even more religious about clean engineering principals and how "prevailing wisdom" is very much needed and will always be needed. That said there are a lot of spaces where not following wisdom works temporarily. But at scale, it crashes and crumbles. Web-apps are a good example of this.
  • fooker 7mo ago
    > You haven't worked or serviced any engineering systems, I can tell. I have worked on compilers and databases the entire world runs on, the code quality (even before AI) is absolutely garbage. Real systems built by hundreds of engineers over twenty years do not have clean code.
    • deleted 7mo ago
      [deleted]
    • namar0x0309 7mo ago
      I never mentioned anything about "clean code".
  • dirtikiti 7mo ago
    I'd argue clean engineering principles (gang of 4 patterns) and clean code are not the same, and are most definitely not mutually exclusive.
• saltyoldman 7mo ago
  I started a side project that was supposed to be 100% vibe coded (because I have a similar view as you). I'm using go and Bubble Tea for a TUI interface. I wanted mouse interaction, etc.. It turns out it defaulted to bubble tea 1.0 (instead of 2.0). The mouse clicks were all between 1 and 3 lines below where the actual buttons were. I kept telling it that the math must be wrong. And then telling it to use Bubble objects to avoid all this crazy math. I am now hand coding the UI because the vibe coded method does not work. I then looked at the db-agent I was designing and I explicitly told it to create SQL using the LLM, and it does. But the ACTUAL SQL that it persists to the project is a separate SQL generator that it wrote by hand. The LLM one that gets displayed on the screen looks perfect, then when it comes down to committing it to the database, it runs an alternative DDL generator with lots of hard coded CREATE TABLE syntax etc... It's actually a beautiful DDL generator, for something written in like 2015, but I ONLY wanted the LLM to do it. I started screaming at the agent. I think when they do take over I might be high up on their hit list. Just anecdata. I still think in a year or two, we'll be right about clean code not mattering, but 2026 might not be that year.
• recroad 7mo ago
  I think clean architecture matters a lot, even more so than before. I get that you can just rewrite stuff, but that comes with inherent risk, even in the age of agents. Supporting production applications with low MTTR to me is what matters a lot. If you are relying entirely on your agent to identify and fix a production defect, I'd argue you are out at sea in a very scary place (comprehension debt and all that). It is in these cases where architecture and organization matters, so you can trace the calls and see what's broken. I get that largely the code is a black box as less and less people review the details, but you do have to review the architecture and design still, and that's not going away. To me, things like SRP, SOLID, DRY and ever-more important.
• CharlieDigital 7mo ago
  Clean code still matters. If it's easier for a human to read and grasp, it will end up using less context and be less error prone for the LLM. If the entities are better isolated, then you also save context and time when making changes since the AoE is isolated. Clean code matters because it saves cycles and tokens. If you're going to generate the code anyways, why not generate "pristine" code?. Why would you want the agent to generate shitty code?
  • WillAdams 7mo ago
    Yes, but the problem is the advocate for it, and the text on it arrived at the correct conclusion using a bad implementation/set of standards. c.f., https://github.com/johnousterhout/aposd-vs-clean-code https://github.com/johnousterhout/aposd-vs-clean-code and instead of cleaning your code, design it: https://www.goodreads.com/en/book/show/39996759-a-philosophy-of-software-design https://www.goodreads.com/en/book/show/39996759-a-philosophy...
• mbesto 7mo ago
  I've seen enough dirty code (900+ tech diligences over the last 12 years) to know that many businesses are successful in spite of having bad code.
  • zer00eyz 7mo ago
    It never started that way. Time, feature changes, bugs, emergent needs of the system all drive these sorts of changes. No amount of "clean code" is going to eliminate these problems in the long term. All AI is doing is speed running your code base into a legacy system (like the one you describe).
    • mbesto 7mo ago
      > All AI is doing is speed running your code base into a legacy system Are you implying legacy systems stop growing because I didn't mean to imply those companies stop growing.
      • zer00eyz 7mo ago
        Not at all, Im saying that in the before time, complexity emerged over time (staff changes, feature creep). AI coding (and its volume) is just speed running this issue.
        • mbesto 7mo ago
          > complexity emerged over time So complexity is an issue? I don't get it. SFDC is an incredibly complex system that makes billions of dollars. Tell me why I would NOT want to be able to create a system like that with an automated tool?
• devin 7mo ago
  Funny you should mention that. I just used a two sentence prompt to do something straightforward. It took careful human consideration and 3 rounds of "two sentence" prompts to arrive at the _correct_ transformation. I think you're missing the cost of screwing up design-level decision-making. If you fundamentally need to rethink how you're doing data storage, have a production system with other dependent systems, have public-facing APIs, and so on and so forth, you are definitely not talking about "two sentence prompts". You are playing a dangerous game with risk if you are not paying some of it off, or at the very least, accounting for it as you go.
  • luc_ 7mo ago
    I don't think they are, I think they're not talking about that... "It's all about the spec."
• DrBazza 7mo ago
  If you work in finance, you've probably just bankrupted your company. Nanoseconds matter. Clean code tends to equal simple code, which tends to equal fast code. The order of items in memory does matter, as does cache locality. 32Kb fits in L1 cache. If of course you're talking about web apps then that's just always been the Wild West.
  • SeanDav 7mo ago
    Humans are quite capable of bankrupting financial companies with coding issues. Knight Capital Group introduced a bug into their system while using high frequency trading software. 45 minutes later, they were effectively bankrupt.
  • aketchum 7mo ago
    nano seconds matter in some miniscule number of High Frequency and Algorithmic trading use cases. It does not matter in the majority of finance applications. No consumer finance use case cares about nanoseconds. The vast majority of money is moved via ACH, which clears via fixed width text files shared via SFTP, processed once a day. Nanoseconds do not matter here.
  • smallmancontrov 7mo ago
    > Clean code tends to equal simple code, which tends to equal fast code. Wat? Approximately every algorithm in CS101 has a clean and simple N^2 version, a long menu of complex N*log(N) versions, and an absolute zoo of special cases grafted onto one of the complex versions if you want the fastest code. This pattern generalizes out of the classroom to every corner of industry, but with less clean names+examples. The universal truth is that speed and simplicity are very quick to become opposing priorities. It happens in nanoseconds, one might say. Cache-aware optimization in particular tends to create unholy code abominations, it's a strange example to pick for clean=simple=fast wishcasting.
  • tracker1 7mo ago
    I'm not sure if you are considering the patterns actually used in "Clean Code" architectures... which create a lot of, admittedly consistent, levels of interface abstractions in practice. This is not what I would consider simple/kiss or particularly easy to maintain over time and feature bloat. I tend to prefer feature-oriented structures as an alternative, which I do find simpler and easy enough to refactor over time as complexity is required and not before.
• raincole 7mo ago
  In the past ~15 years, there are only two new languages that went from "shiny new niche toy" to "mainstream" status. Rust and Go[0]. This fact alone insinuates that the idea of having unlimited memory or unlimited CPU clocks is just wrong. [0]: And TypeScript, technically. But I'd consider TypeScript a fork of JavaScript rather than a new language.
  • kriro 7mo ago
    Swift is at least in the TIOBE Top 20 (#20) and Scratch is at #12 but more educational. I'd also add Kotlin and Dart as contenders which sit just outside the top 20.
  • tracker1 7mo ago
    Rust is still considered by many to be pretty niche... as much as I like Rust and as widely as it is starting to be used. I especially like it with agent/ai use as the agent output tends to be much higher quality than other languages I've tried with them.
  • rvz 7mo ago
    Zig. So make that 3. It is also used in Ghostty, Bun which is the JS runtime that powers OpenCode, and Claude Code.
    • rickette 7mo ago
      Still Go/Rust/Typescript is on a whole other level of adoption compared to Zig
• williamdclt 7mo ago
  Amongst others reasons, one of the reasons for clean code is that it avoids bugs. AIs producing dirty code are producing more bugs, like humans. AIs iterating on dirty code are producing more bugs, like humans.
• embedding-shape 7mo ago
  > a two sentence prompt fixes it in a million line codebase in thirty minutes. Could you please create a verifiable and reproducible example of this? In my experience, agents get slower the larger a repository is. Maybe I'm just very strict with my prompts, but while initial changes in a greenfield project might take 5-10 minutes for each change, unless you deeply care about the design and architecture, you'll reach 30 minute change cycles way before you reach a million lines of code.
  • fooker 7mo ago
    Your observation was valid in 2025. This is largely a solved problem now with better harnesses and 1M context windows.
    • embedding-shape 7mo ago
      No, it's valid still in 2026, I'm literally using most agents on a day to day basis. As mentioned, I'm happy to be proven otherwise, otherwise please stop just trying to say "It's not like that anymore" when supposedly it's so easy to prove. PoC||GTFO, as we used to say back in the day when they people shipping software actually knew how to write software.
      • fooker 7mo ago
        > I'm happy to be proven otherwise I am getting the impression that you'd be moving goalposts :) I just checked out clang+llvm, 24 million lines of code, and implemented a simple C++ language extension with claude 4.6 opus high in less than five minutes. Complete with tests. Debugging and optimizations working seamlessly. (It's a simple pattern matching implementation, if anyone's curious.)
        • embedding-shape 7mo ago
          > I am getting the impression that you'd be moving goalposts :) Nope, the original goal post you set was "implementing large changes are easy [...] a two sentence prompt fixes it in a million line codebase in thirty minutes", I'm more than happy for you to prove just that, no moving. > I just checked out clang+llvm, 24 million lines of code, and implemented a simple C++ language extension with claude 4.6 opus high in less than five minutes. Complete with tests. Debugging and optimizations working seamlessly. Awesome! Please share the steps to reproduce, results and the prompt?
• bcrosby95 7mo ago
  I've been working on a client/server game in Unity the past few years and the LLM constantly forgets to update parts of the UI when I have it make changes. The codebase isn't even particularly large, maybe around 150k LOC in total. A single complex change (defined as 'touching many parts') can take Claude code a couple hours to do. I could probably do it in a couple hours, but I can have Claude do it (while I steer it) while I also think about other things. My current guess is that LLMs are really good at web code because its seen a shitload of it. My experience with it in arenas where there's less open source code has been less magical.
  • fooker 7mo ago
    I suspect you are not using plan mode?
• stickfigure 7mo ago
  I actively use AI to refactor a poorly structured two million line Java codebase. A two-sentence prompt does not work. At all. I think the OP is right; the problem is context. If you have a nicely modularized codebase where the LLM can neatly process one module at a time, you're in good shape. But two million lines of spaghetti requires too much context. The AI companies may advertise million-token windows, but response quality drops off long before you hit the end. You still need discipline. Personally I think the biggest gains in my company will not come from smarter AIs, but from getting the codebase modularized enough that LLMs can comfortably digest it. AI is helping in that effort but it's still mostly human driven - and not for lack of trying.
  • fooker 7mo ago
    Have you tried this in the last few months with an expensive model? (Claude 4.6 opus high, for example) You might be pleasantly surprised if you haven’t yet.
    • stickfigure 7mo ago
      I'm using Opus 4.6, "Effort level: auto (currently high)". Used it a fair bit this week. Results are still pretty mediocre. It's useful, but not "give it a two sentence prompt" useful.
      • fooker 7mo ago
        Are you using the planning mode? That's the way to get it to plan an exact set of actions, given a two sentence prompt.
        • stickfigure 7mo ago
          No, but I will definitely try it. Thanks.
• mjr00 7mo ago
  > I’ll go against the prevailing wisdom and bet that clean code does not matter any more. No more than the exact order of items being placed in main memory matters now. This is a really funny comment to make when the entire Western economy is propped up by computers doing multiplication of extremely large matrices, which is probably the single most obvious CompSci 101 example of when the placement of data in memory is really, really important.
• johntash 7mo ago
  One thought I've had a few times is "well.. this is good enough, maybe a future model will make it better." so I won't completely disagree. But my counter argument is that the generated code can easily balloon in size and then if you ever have to manually figure out how something works, it is much harder. You'll also end up with a lot of dead or duplicated code.
• grey-area 7mo ago
  > If you are not happy about how something is designed, a two sentence prompt fixes it in a million line codebase in thirty minutes. This fantasy is so far from reality with current systems and is unlikely to ever be fulfilled, even if they were a lot more capable.
  • fooker 7mo ago
    I hope you understand that close to 100% of software developers employed by large companies have effectively unlimited access to the latest models and tools. Denialism would have presumably worked if this was something not a lot of people had seen or used.
    • grey-area 7mo ago
      I’ve used these tools, they are really useful at times but they do not provide reliable fixes over 1 million lines with a two line prompt.
• pocksuppet 7mo ago
  Actually we're going back to caring about the order of atoms in main memory. When your code has good cache locality and prefetching it can run 100 times faster, no joke. Arranging your program so the data stays in a good cache order is called data-driven design - not to be confused with domain-driven design.