top 50 comments

sorted by: hot top controversial new old
[–] 214 points 5 months ago (7 children)

Yes, and so can most experienced developers. In fact unmaintainable human-written code is more often caused by organisational dysfunctions than by lack of individual competence.

  • source
  • hideshow 7 child comments
  • [–] 102 points 5 months ago (2 children)

    In my experience there’s usually a confluence of individual and institutional failures.

    It usually goes like this.

    1. hotshot developers is hired at company with crappy software
    2. hotshot dev pitches a complete rewrite that will solve all issues
    3. complete rewrite is rejected
    4. hotshot dev shoehorns a new architecture and trendy dependencies into the old codebase
    5. hotshot new dev leaves
    6. software is more complex, inconsistent, and still crappy
  • source
  • parent
  • hideshow 2 child comments
  • [–] 21 points 5 months ago* (last edited 5 months ago) (1 child)

    That's one of the failure modes, good orgs would have design and review processes to stop it.

    There are other classics like arbitrary deadlines, conflicting and shifting requirements and product direction, perverse incentives, etc.

    I would even say that the AI craze is a result of the latter.

  • source
  • parent
  • hideshow 1 child comment
  • load more comments (4 replies)
    [–] 80 points 5 months ago* (last edited 5 months ago) (4 children)

    Pretty sure I can, considering I’m still maintaining a project I originally started in 2009, which is a core component of my email service.

  • source
  • hideshow 4 child comments
  • [–] 8 points 5 months ago (3 children)

    Please tell me the software patent in that project is copylefted

  • source
  • parent
  • hideshow 3 child comments
  • [–] 11 points 5 months ago* (last edited 5 months ago)

    The one in Port87 is the only patent I have, and it is not copyleft. I have tons of open source code that I could have patented, including in Nymph, but didn’t. Now that prior art exists and is in the market, those things can’t be patented.

    There’s very little reason to seek a patent except to offer the product for sale in the market. It’s wildly time consuming and expensive. Mine cost me about $17k and took me three years to get. And I’m not a big company with mountains of cash and lawyers on the payroll. I patented it so that Microsoft, Google, etc. couldn’t just see my idea and be like, “that’s good, let’s take it”. That would kill my business. Copylefting the patent would allow them to do that.

  • source
  • parent
  • [–] 59 points 5 months ago (9 children)

    I mean, yes, absolutely I can. So can my peers. I've been doing this for a long, long time, as have my peers.

    The code we produce is many times more readable and maintainable than anything an LLM can produce today.

    That doesn't mean LLMs are useless, and it also doesn't mean that we're irreplaceable. It just means this argument isn't very effective.

    If you're comparing an LLM to a Junior developer? Then absolutely. Both produce about the same level of maintainable code.

    But for Senior/Principal level engineers? I mean this without any humble bragging at all: but we run circles around LLMs from the optimization and maintainability standpoint, and it's not even close.

    This may change in the future, but today it is true (and I use all the latest Claude Code models)

  • source
  • hideshow 9 child comments
  • load more comments (3 replies)
    [–] 49 points 5 months ago (2 children)

    Maybe the real slop was the code we wrote along the way

  • source
  • hideshow 2 child comments
  • load more comments (2 replies)
    [–] 44 points 5 months ago

    Yes. That's literally the first point in my job description.

  • source
  • [–] 43 points 5 months ago (1 child)

    When that coworker tells you "hah you must have generated this" but you coded this yourself 👀

  • source
  • hideshow 1 child comment
  • [–] 43 points 5 months ago (22 children)

    ITT: AI induced dunning-kruger. Everybody can write maintenable code, just somehow it happens that nobody does.

  • source
  • hideshow 22 child comments
  • [–] 50 points 5 months ago (12 children)

    Most of the unmaintainable code I've seen is because businesses don't appreciate the need to occasionally refactor/rewrite or do anything to maintain code. They only appreciate piling more on. They'd do away with bug fixing too if they could.

  • source
  • parent
  • hideshow 12 child comments
  • load more comments (10 replies)
  • [–] 16 points 5 months ago (3 children)

    Can I, sure. Do I give af since my company doesn’t care about me as anything other than a number in a spreadsheet, no.

  • source
  • parent
  • hideshow 3 child comments
  • [–] 5 points 5 months ago (2 children)

    Well, even for my private projects that I care about I end up having to rewrite every few years.

  • source
  • parent
  • hideshow 2 child comments
  • [–] 7 points 5 months ago (1 child)

    It really depends on the situation. Can I write maintainable code? Yes, to the extent that the average senior dev can.

    But that isn’t the same as being afforded the chance to write maintainable code. I’ve been part of teams where the timeline is so tight that technical debt is just a thing that builds up to be dealt with “later” and more stress is put on getting things done instead of keeping things maintainable.

    The fact of the matter is that humans can while LLMs currently can’t.

    On top of that, a human dev is going to be able to understand context a hell of a lot easier if they’ve previously worked on it, even if the code is less maintainable.

  • source
  • parent
  • hideshow 1 child comment
  • load more comments (1 reply)
  • load more comments (3 replies)
    [–] 37 points 5 months ago (1 child)

    Guys, you can laugh at a joke. The AI doesn't win just because someone upvoted a meme. Maintainability of codebases has been a joke for longer than LLMs have been around because there's a lot of truth to it.

    Even the most well intentioned design has weaknesses that we didn't see coming. Some of its abstractions are wrong. There are changes to the requirements and feature set that they didn't anticipate. They over engineered other parts that make them more difficult to navigate for no maintainability gain. That's ok. Perfectly maintainable code requires us to be psychics and none of us are.

  • source
  • hideshow 1 child comment
  • load more comments (1 reply)
    [–] 36 points 5 months ago (1 child)

    No, so let's vibe unmaintainable code together!

  • source
  • hideshow 1 child comment
  • load more comments (1 reply)
    [–] 35 points 5 months ago (10 children)

    I might not be the best, but I can still do a better job than AI

  • source
  • hideshow 10 child comments
  • load more comments (10 replies)
    [–] 30 points 5 months ago (1 child)
    load more comments (1 reply)
    [–] 28 points 5 months ago
    [–] 21 points 5 months ago (1 child)

    Why would you tell on yourself like this?

  • source
  • hideshow 1 child comment
  • load more comments (1 reply)
    [–] 21 points 5 months ago
    [–] 18 points 5 months ago (1 child)

    I could.

    I choose not to! Take that, LLM!

  • source
  • hideshow 1 child comment
  • load more comments (1 reply)
    [+] 15 points 5 months ago* (last edited 4 months ago) (1 child)
    load more comments (1 reply)
    [–] 15 points 5 months ago (3 children)

    More maintainable that whatever shit it put out

    Frankly I believe it can be maintainable if the person doing the prompting actually does something and correctly do their role of human reviewing and correcting. Vibe coding without any review is dooming the software maintainability

  • source
  • hideshow 3 child comments
  • [–] 10 points 5 months ago

    In my experience, the biggest problem is that maintainable code necessarily requires extending/adapting existing structures rather than just slapping a feature onto the side.

    And if we're not just talking boilerplate, then this necessarily requires understanding the existing logic, which problems it solves, and how you can mold it to continue to solve those problems, while also solving the new problem.

    For that, you can't just review the code afterwards. You have to do the understanding yourself.
    And once you have a clear understanding, it's likely that the actual code change is rather trivial. At least more trivial than trying to convey your precise understanding to an LLM/intern/etc..

  • source
  • parent
  • load more comments (2 replies)
    [–] 14 points 5 months ago
    [–] 14 points 5 months ago

    This attack must go against the laws of robotics.

  • source
  • [–] 13 points 5 months ago

    yes. yes I can. been doing it for 25 years.

  • source
  • [–] 12 points 5 months ago

    I'm ass at coding and I still can, lmao

  • source
  • [–] 12 points 5 months ago

    I can produce NI-slop on my own. I don't need AI to do it for me.

  • source
  • [–] 12 points 5 months ago

    I can maintain any code I write myself, so long as I look at it at least once every month

  • source
  • [–] 12 points 5 months ago

    I would like to think that I'm capable of writing maintainable code like seemingly everyone else in this thread, and I have multiple code bases that have existed for decades that have included necessary updates over time to reinforce that opinion.

    I've also seen some truly unfathomable, Lovecraftian horror code in the wild that has persisted for decades.

    Seeing Will Smith's character as a representative of humanity, and Sonny as a representative of LLM/GenAI in that context makes this joke absolutely hilarious.

  • source
  • [–] 10 points 5 months ago (1 child)

    You don't have to outrun the bear, you just have to outrun the other guy.

    I think most devs here can out-maintainable-code an llm.

  • source
  • hideshow 1 child comment
  • load more comments (1 reply)
    [–] 10 points 5 months ago (2 children)

    10 PRINT 'Hello World!'

    20 GOTO 10

    EZ

  • source
  • hideshow 2 child comments
  • [–] 7 points 5 months ago* (1 child)

    Infinite loop and hard coded magic constant; this should have a configurable timeout and a resource file the string is read from so we can internationalize the application. Additionally, the use of a goto with a hard coded line number is a runtime bug waiting to happen after unrelated refactors; it's best to use a looping construct that has more deterministic bounds.

  • source
  • parent
  • hideshow 1 child comment
  • load more comments (1 reply)
  • [–] 8 points 5 months ago (1 child)
    load more comments (1 reply)
    load more comments
    view more: next ›