Yes. Also, my llms can do it too
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.
I actually laughed out loud at this meme.
Yes, but only I can maintain it.
I can maintain it. But I won’t.
10 PRINT 'Hello World!'20 GOTO 10EZ
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.
ouch
No, so let’s vibe unmaintainable code together!
I might not be the best, but I can still do a better job than AI
This is a bold claim I will not make.
If you are complete novice then obviously not but I think anyone reasonably proficient in a language would be able to identify optimisations that an AI just doesn’t seem to perceive largely because humans are better at context.
It’s like that question about whether it’s worth driving your car to the car wash if the car wash is only 10 metres away. AIs have no experience of the real world so they don’t inherently understand that you can’t wash a car if it’s not at the car wash. A human would instantly know that that’s a stupid statement without even thinking about it, and unless you instruct an AI to actually deeply think about something they just give you the first answer they come up with.
I agree with you. But the tool will output a basic code that mostly do what asked in seconds instead of tens of minutes if not hours. So now we could argue if the optimization you make are worth the added cost I’d writing the code yourself or if it’s better to have the tool to generate the code and then optimizing it.
What’s why they’re pushing for the datacenters, they want to turn make every query that deep. The tech is here, but the ability to sustain it isn’t. They build the data centers, kick the developers out, depress the education market for it, and then raise the prices.
Companies will be paying the AI companies 60k per year per seat in a decade.
At that price it would be cheeper to use humans
That’s the brilliance. There won’t be a pool of trained young developers by then.
What makes you think there will be a decade passing with any result to exist from here?
A tale as old as time. The US nuclear missile codes were 000000, but it didn’t matter. The chain of command was purpose-built, ironically, so the front line soldier in a cold war scenario had to make the last decision to delete all life on the planet. Chain of command doesn’t matter at that point. You are choosing to kill everyone you know from an order from who knows who. The ultimate checksum.
You will always be better at decisions than an n-dimensional matrix of numbers on an overpriced GPU.
You will always be better at decisions than an n-dimensional matrix of numbers on an overpriced GPU.
I’d be careful about these claims. Maybe with our current iteration of “attention-based” LLMs, yes. But keep in mind that our way of processing information is strongly limited compared to how much data is fed to these LLMs while training, so they in theory have a lot more foundation to be able to reason about new problems.
We’re vastly more capable at the moment at interpreting our limited view on foreign code, being actually creative, find new ways to reason, yes. Capable developers (open source…) often have seen quite a bit more code than the average developer and are highly skilled, still with just a tiny subset of the code that an LLM has seen.
But say these models improve in creativity and “higher-level of thought” through whatever means (e.g. through more reinforcement learning). Well, let’s just say I’m careful with these claims. These LLMs are already quite a help with stupid boilerplaty code (less so with novel stuff, and writing idiomatic non-redundant code, but compared to 2-3 years ago it’s quite a step already, to the point that they’re actually helpful, disregarding all the hype and obvious marketing strategies of these AI-companies)
I don’t understand your point about the solider on the front line, but I’m interested. If you get a chance, can you elaborate please?
yes. yes I can. been doing it for 25 years.
Maybe the real slop was the code we wrote along the way
But, I didn’t check any of mine in?
Bah, you both read the same Stack Exchange. But it remembered it byte for byte.
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)
With LLMs I get work done about 3-5x faster. Same level of maintainability and readability I’d have gotten writing it myself. Where LLMs fail is architecting stuff out- they can’t see the blind alleys their architecture decisions being them down. They also can’t remember to activate python virtual environments, like, ever.
I think it depends on what you’re writing code for. For greenfield/new features that don’t touch legacy code or systems too much? Sure, I agree with that assessment.
Unfortunately that’s a small fraction of the kind of work I am required to do as most of the work in most places doing software dev are trying to add shit to bloated and poorly maintained legacy systems.
Working in those environments LLMs are a lot less effective. Maybe that’ll change some day. But today, they don’t know how to code reuse, refactor methods across classes/design patterns, etc. At least, not very well. Not without causing side effects.
The biggest problem with using AI instead of junior developers is that junior developers eventually become senior developers. LLMs … don’t.
They might, but it does not seem likely to me and is definitely not guaranteed.
It’s more likely than it happening with an LLM, though. Without junior developers the number of future senior devs approaches zero.
Sorry, my wording was very unclear. I was referring to the LLMs having a small but non-zero chance to actually get good enough to replace senior devs.
You are right though, chances for the average junior dev to reach senior status are much better than for LLMs to reach that stage any time soon (if ever).
sir, this is programmer_humor
😞 Sir this is a Wendy’s.
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.
Every bad decision in my code bases were because I didn’t have enough time to do things the right way
Not in my case. I dont write spaghetti code, i write fettuchini code
Yes. But the important thing is that now disfunctional organizations have access to tools to write unmaintainable code really fast.
In my experience there’s usually a confluence of individual and institutional failures.
It usually goes like this.
- hotshot developers is hired at company with crappy software
- hotshot dev pitches a complete rewrite that will solve all issues
- complete rewrite is rejected
- hotshot dev shoehorns a new architecture and trendy dependencies into the old codebase
- hotshot new dev leaves
- software is more complex, inconsistent, and still crappy
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.
Yeah, certain code developed organically (aka shifting demands). Devs know the code gets worse, but either by time or money they don’t have the option to review and redo code.
When that coworker tells you “hah you must have generated this” but you coded this yourself 👀
“You need to try your best” “This was my best…”
ITT: AI induced dunning-kruger. Everybody can write maintenable code, just somehow it happens that nobody does.
Every decision I’ve made to write code with poor maintainability was driven by time pressure to deliver
Which is the norm, not the exception. Really good devs (which I’m not) are capable of delivering clean, modular, readable and maintainable code under pressure, working in a team with other people, with unclear requirements.
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.
This is why AI coding is being pushed so hard. Guess what’s great at piling on at 30x speed? If piling on is all companies appreciate then that’s what they’ll demand.
This 100%
Many opensource projects are in same state, I know for sure my projects become spaghetti if I work more than a year on them.
Besides, I’d argue that if you need to rewrite (part of) it is because it wasn’t maintainable in the first place.
I disagree.
Rewrites can happen due to new feature support.
For examlle: It’s entirely possible that a synchronous state machine worked for the previous needs of the software, but it grew to a point where now that state machine is unable to meet the new requirements and needs to be replaced with a modern fam with asynchronous singals/delegates.
Just because that system was replaced doesn’t mean that it wasn’t maintainable, wasn’t readable, or easy to understand. It just wasn’t compatible with the growing needs of the application.
It can, but usually that’s not the case.
I disagree. Rewriting is a core component of maintaining a code base. It’s the evolution of code. Not rewriting and hooking in some janky way is much worse. No one can see all the possible needs of code the first time they write it. Or even the tenth. Updating the code by rewriting sections is the healthier way to use everything you learned since the first time you wrote it to keep it clean and improve it.
Exactly. Elegant code requires domain expertise, which no one has on during the first attempt.
Strident attempts at elegance during the first domain-expertise-free try tend to just result in different kinds of shitty code.
Of course, experienced programmers can obviously achieve lower shittiness, from day one.
But truly elegant code requires exploring the domain, and learning what works there.
Shitty or barely-good-enough code often walks so that elegant code can someday replace it.
Well, if rewriting is maintaining, everybody can write maintenable code.
Did it become a mess? Rewrite time!
For me the art is writing it so you don’t need to rewrite and you don’t need a janky temporary permanent workaround if requirements change. Clean interfaces, SOLID, plug-ins, etc. Can’t do it myself, but the legendary 10x devs usually do.
The most maintainable code is built to be replaced with minimal impact.
How much of the program will must be replaced if you remove one module? If you need to replace the entire program, then your program is not maintainable. Too much is heavily dependent on this module.
I don’t believe in code that never needs a rewrite, but scalable code should be compartmentalized and future-proofed to the point that the next rewrite can be pushed as far into the future as possible. Me personally, I tend to discover what these best practices are during those rewrites.
All code is maintainable with enough time and money.
But yes, well structured code where those rewrites are minimal is the goal.
There probably is a threshold where the amount you have to rewrite becomes too high. But with each rewrite, hopefully the next time you have a section you need to redo its smaller that before. Eventually going from rewriting a couple thousands of lines to just a hundred or so on the 5th iteration.
My company is totally like this. If you don’t write a shiny new feature immediately, you don’t last.
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.
Well, even for my private projects that I care about I end up having to rewrite every few years.
That’s just the norm tbh. You learn new techniques, the language gets new optimizations, keywords and shortcuts. That doesn’t mean your code is unmaintainable.
I rewrite it because it becomes a mess of asymmetric assumptions, weird dependencies and hacky extensions, I can’t really blame the language for that one.
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.
Well, I interpret the question as “can you write maintenable code under typical corporate conditions and timelines”. Very few can, but I’ve seen them.
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.
Please tell me the software patent in that project is copylefted
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.
Its Apache 2.0
Port87 is not Apache 2.0. There are no patents that cover Nymph.js, which is the one that’s Apache 2.0.
ITT:
In this economy?
