The focus on "code" is sometimes too strong. This isn't just a code/quant issue. All of this applies too to any "answer" the LLM gives. Experts very often track their lineage - what teachers they had - because the details and slant of what they were taught guided their way of thinking and defined the "handle" they use to grab a problem. There is no "right way" to do most things - there are ways of approaching. Imagining that you are free-flowing and not in a channel is a rookie mistake! Encouraging this way of thinking is like the uptight enforcer of minor social mores: "Elbows!" no elbows on the table is how things are done and this is reified. Like you said "it takes no effort to produce and immense effort to debunk" and sometimes the stakes are high. I'm convinced that racism, for example, operates exactly like this: 0 friction go-with-the-flow insist it is natural...
That's very hard to do in a work environment where you have someone above you who doesn't understand or care about this. Instead of keeping things sane so they can run smoothly, you will be seen as slowing down progress.
If I work for someone else it's not my problem. I should point the problem out to them, but since it will hurt them first and foremost, it's no major concern of mine.
It's quite hard to rise above this stuff. The only time I was really able to do it was while contracting because I knew I would be gone in a short while. Even then I was usually fairly blunt about it.
Make it clear that workslop is produced by the human committer and not the Claude. The human has a reputation and this is hurting that reputation.
You can do this in a professional way but still get the point across that they're stealing productivity from others that have to pull up their slack.
If the commits are too big or too dense. Make them break it up, clean up the comments etc. Otherwise they are simply doing a poor job. Not Claude, them.
Corporate code is typically terrible anyway. For many years (predating LLMs) I’ve looked askance at my bank’s app with its obvious bugs, wonder how many are not visible. It was not always so (consider SABRE back in the 60s)
But it’s the fat part of the bell curve. There’s loads of even worse crap outside corporate code…and at the right end of the bell curve is deeply thought out and the result of long-term maintenance that tends towards as bulletproof as can be possible in this universe, parts of OSes, networking stacks, clocks, and the like.
It’s only because that stuff is so robust and sufficiently general that the rest of the world’s steaming pile of code works at all.
> Corporate code is typically terrible anyway. For many years (predating LLMs) I’ve looked askance at my bank’s app with its obvious bugs, wonder how many are not visible. It was not always so (consider SABRE back in the 60s)
I don't know if I've worked on your bank's app (safe bet is I haven't), but I have worked on some banks' apps and... oh boy. Let's just say that if you've seen what I've seen, "stuff it into a mattress" starts looking like a sound financial policy.
If AI does anything, it amplifies asymmetries. Hacking, scamming, reducing code quality... its really good at making defending against those hard problems even harder.
I’m an advocate for LLMs to code and basically use it for everything now, but just want to say you really nailed that.
It takes effort to debunk because you have to holistically consider what the problem was and actually find the better solution to prove why it’s lacking.
In other words, to debunk it, you have to do the actual work that wasn’t done the first time.
Some people may argue “so what?”
And to that I would just respond that the fast solution implies nobody probably thought about it, which is always risky and generally leads to very bad outcomes. If for no other reason than there is at least no consensus, which for long-term software evolution is deeply problematic.
This has happened many times since this trend has started, and forcing everyone to step back after a year objectively reveals the murder that has been committed that, believe it or not, is not trivially unwound.
In the wrong hands it’s a debt machine that is already killing companies from the inside.
I see increasing amounts of code merged to the codebase that is sometimes wrong, sometimes too brittle, sometimes fixes the symptom without addressing the bug. Two years ago the same code would be criticized harshly and reworked before being accepted.
Also, now people who used to manage the development but not write any code also feel their superpowers to merge LLM slop in humongous amounts. It feels like a ticking time bomb, but I am afraid of calling it out and rain on their parade of 10x productivity (or often AI psychosis). Leaving the team doesn't feel like a good decision because what I hear from many colleagues is much worse. Ah what a time to be alive...
The Bullshit Asymmetry Principle, a/k/a Brandolini’s Law: “the amount of energy needed to refute bullshit is an order of magnitude bigger than that needed to produce it".
My strategy is to skim the workshop to find suspicious sections, then prioritize debunking at least one part that makes the creator look bad.
Then respond with that addressed, with a firm but polite explanation that the document has some problems that need to be addressed carefully before we invest time on it.
None of this works if it’s coming from your boss, but it’s very effective at making people think twice before sending you slop.
People only do the workslop thing when they believe the benefits of showing the work outweigh the reputational risks. If they get caught every time they do it and exposed on an email chain, they start doing less.
Sadly not my experience. When I give this kind of feedback on a document, highlight a gap, or give constructive feedback, most of the time this feedback is fed back to the AI and a new revision of the document shows up.
BUT because it is AI it's not that section that's addressed, it's about 90% of the document that now has changed, and I need to spend another gargantuan effort to review it. It's like by trying to be helpful I actually lose more time.
The AI has made it so that the thinking before writing is mostly gone, and shifted that step to the reviewers.
Left this way, every collaboration can turn into what used to be the worst nightmare type with that one unavoidable stakeholder or coauthor who likes to procrastinate and then create an insane fire drill in the final moments before a deadline.
Now, no matter the amount of preparation work, those last rounds can completely rewrite something with no hope of review. No iterative improvement. No ratcheting towards a known quality. Just a bunch of cargo cult review followed by YOLO-style, vibe-everything absurdity.
Review burden is increasingly higher for many people, with Tech likely being patient 0 for the rest of the economy.
The ratio of verification capacity to generation capacity, V/G, has broken with LLMs. It’s not simply an issue of more generation or less review.
The impression seems to be that individuals are more productive, but that productivity is someone else’s review burden. So the team/firm as a whole is not better off.
The cheap generation of content does mean that reviewer capacity is now a limited resource.
Unless your firm is aware and is measuring time spent on reviewing slop, there is no incentive or structure to ensure that time is respected and valued.
This is a management and awareness problem since the typical response is “use a bot to review it.”
I believe this is most clearly visible in mathematics. Who is going to review the 700 proofs put out by OpenAI in a single day ? And even if mathematicians could, how will they handle the exponential growth of LLM-generated proofs ?
Not to say these proofs are slop, even if the LLM-generated work is of good quality, what happens when no one knows how it works anymore ? Even if you ask the LLM to explain, which it does quite badly, the time to understand the explanation is incompressible.
So in the end, productivity will probably reach a ceiling that we can estimate as the product of humans, their cognitive capacity and their time. And that ceiling may be lower than what AI companies valuation expect, regardless of the compute and they can pump out and the RSI level they can reach.
This is about computer code. Debunking is either "it runs or doesn't". Not hard.
Presentation layer code doesn't control how the machine and kernel prioritize anything; so "proof" Ruby code is doing the right thing is proving the machine does the right thing from the factory.
As for abstract theory and math, well shit since any English and any math are...mathematically possible...well shit I guess we gonna have to live in the real world and not inside a rhetorical bubble; religious or atheist philosophy... cause they are not evenly distributed frameworks as religion clearly shows; so why live by the syntax and semantics of some mathematical rando who taught a stats class years ago?
Same shit as living by religious allegory
Goodhart's Law has come for 1900s means of scientific inquiry; every technology follows an S-curve and the same for every social society. In the US we aren't all defaulting to calling ourselves British or speaking Latin.
Physics will always be there. The stupid glyphs and bird song we came up with to communicate about it isn't physics. It's just a human language system.
By default, an llm isn't going to give harsh criticisms like 'you've architectured this thing completely wrong with a poor choice of abstractions and algorithms'. As the post says, you still need to think.
Yep; tons of references to programming, Ruby, SQL, other technologies
None of which have much to do with how the hardware handles requests.
Am an EE with a background in applied physics and well aware we could jam a kernel in the BIOS/UEFI storage and generate the runtime state around it at boot from a prompt cause I am working on just that
Which is exactly where we are headed with Jev/decision models; they can generate new config to min/maxing per process resource use; look into bpf and sched_ext and meditate on their application. It should eventually jump out at you
We have known in the abstract how to handle computing efficiently on our machines since we started building transistor based machines
It doesn't require handing a bunch of meat suits verbose languages/bloated state machines to manually tweak the parameters of and make mess of electrical state management
Writing code is not high tech. It's 1970s and 1980s tech. As this forum should be well aware tech evolves with the times.
The coder bros refusal to move on is them clinging to a sunk cost fallacy; but they already put time and $$ into their education in ugly languages and DSLs that merely initialize values in memory and ask the hardware to run it within some spacetime constraints
The syntactic gibberish is just a barnacle of a bygone era
Social web addicted Millennials need to grow up and move on
It's worth noting that the context here is a system that was translated by an LLM which is the ideal use case for it. 90% of the thinking had already been done by developers of the existing system.
Yeah, I think most success stories in AI seem to come from ports, or from projects where a deliberate architecture has been laid by humans who understand it, and AI is sprinkling features on top. Adding features and drivers to a Linux distro seems like one of those places where AI is uniquely well positioned to bring value, because the foundation has already been laid.
I wrote a post the other day on how agentic code still needs this kind of architectural foundation to not end up in a tangled mess. It might interest someone:
https://ljtn.github.io/epiq/blog/the-soft-fabric-of-agentic-...
anecdotally this has been a huge help for my projects. I'm seeing AI one-shot porting from one library/framework to another with very minimal handholding. It used to be that these decisions needed to be thought through a lot because they were hard to change later on
I agree with what I think you're implying, but if it needs to be started explicitly: converting a 100% handwritten, high quality repo to an different language via LLM should be trivial, because all of the hard parts have been reasoned through, and yet these conversions had mistakes, which is unimpressive. Rectifying the mistakes is non-trivial, and the LLMs did not have foresight to rectify them in advanced. (Expectant "you're right, I [sic] did completely fuck that up")
That said, I don't know if it matters at this point.... On top of Brandolini's law (mentioned elsewhere), what's more likely to happen is that developers' intellect, made available in open source, is just going to be harvested as context for different projects (I'm not taking about training data, I'm taking about devs literally cloning repos into an agent to harvest intellect).
That's a really great point, and you can often start with documenting current behavior with tests and then carefully going through to figure out what bugs you've just enshrined in test cases…
“Ideal use case” such a wild take. The “10%” (assuming you mean all the issues pointed out in the article) are the things that take the most time and effort to do (or fix now), which you can’t do without understanding and fixing the “90%” of “translation”.
You simply pointed out that challenges remain in what the other poster said is otherwise the ideal use case, which was his point. What is the ideal use case in your opinion, since you disagree?
You need to understand the system you're working on enough to make well-informed decisions about its current and future states.
In some cases you can get away with not reading the code. And maybe in the future that will be more common. But for now, I personally prefer to read (or skim) the code, and not abdicate to AI.
All of this "you need to understand the code" discussion reminds me of when I was an undergrad. I worked in a computer with someone a fair bit older -- they had even worked with punchcard systems. He was always happy to oblige us with war stories from the olden times & we would lap them up.
He favorite axe to grind was how my generation put too much trust into the compiler. "Just because it compiles doesn't mean you're done. You need to look at the actual assembly. Compilers can be VERY inefficient."
This was in the 90s. There was some merit to his claim.
But today? How many people who write Javascript look at the actual assembly code that is run? Not many.
I can't help but wonder if this current "you need to understand the code" is the same thing all over again. And if in a few years, almost nobody will look at the generated Python, Ruby, etc.
Yes I agree thinking is still needed off course, but it has never been easier to ship 'half baked' things that don't actually matter and just works. What I mean is, if something has little proven business value, why waste time making sure it is correctly implemented? I'd rather spend time thinking about things that has actual proven business value, otherwise I'm not opposed to shipping something that I understand only 60 or 70% and save energy. ie: how it works at a high level.
If we are going to the moon, then by all means I think we should probably scrutinize every single line of code, but most business aren't going to the moon.
Yep AI will just invent the missing stuff; that's not purely an AI thing, we do the same as well until we become experienced enough to know what questions to ask in order to narrow down vague requirements.
If I'm tired, yep I'm going to write more sloppy code, I'll put less thought into it and be more tempted to tell the AI 'just do it'. That hasn't changed. I'm not sure where this new breed of "don't read the code" is coming from when it's actual software engineers making the statement; maybe it's just over-excitement and it'll die down (hopefully).
Or it's just over-simplification -- I don't read ALL the code either anymore, but at the same time I'm reading SOME of the code. Tell your AI agent you're doing a code review workshop, ask it to select ten files at random and then go through them with you one at a time. Ask it to review common anti-patterns and put them in your coding standard. Then you can start asking it to review and fix code against your standard as a first pass. You'll still need to manually review the code to keep it in check, but at least you can make it a bit less daunting and a little more fun by actively collaborating on the AI with the review.
I'm learning it's just a 'different kind of tired'. AI has made some stuff much more efficient, including the choice between efficiency and carefulness. You can make that choice at a micro level and very quickly now if you want. There's still fatigue though, it's just a different kind of fatigue. You still get tired from all the thinking. You can still choose to put the work in or not and it still makes a difference. It's just a different kind of difficult. Doesn't mean that the thing to do is to throw your hands in the air and declare that your job shouldn't be difficult or include hard work anymore.
Reading the code is not good for AI corporations bottom line. If programmers are needed to read the code, you can’t create a narrative of complete labor replacement. But they don’t have a real solution to make the LLM output good enough to not need a review, so here we are.
Oh I totally get that; I just don't understand why someone like DHH actually thinks that you don't have to read the code, if that's what he actually thinks. He's not a clueless C-suite.
Most of this article went over my head, but I think this is key point:
if your prompt is not specific enough, many decisions are a coin flip.
If you are using AI, you still have to know what you want it to do. If you are a project manager and give your team incomplete requirements, the result may not be unlike this.
There is a hundred-mile gap between those two places. "Write a register-based VM with a zig-style flat AST" is a lot less work than actually writing it. That's the kind of direction it needs.
There are decisions you care about, and ones you don't. Things like naming conventions or formatting probably belong to the latter category, and in that case having the AI arbitrarily decide isn't going to matter.
I mean this sentence is just wrong. Coin Flips are 50/50 and I assume most decisions are not 50/50 and coding agents dont use high temperature so they don’t even very so much anymore. This sentence is a sentence to me that discredits a whole article because it’s just wrong.
Also practically it’s not a good way of seeing it. It would aim for the average solution of the problem which might not what you need, but its not a coin flip.
Or an alternative: The whole background why in Dune thinking machines are outlawed and how it came to pass, that humanity had to fight the Butlerian Jihad.
"Won't that be grand! Computers and programs start thinking, and the people will stop!" —Walter Gibbs, Tron (1982)
"I just realized another great thing about humans: You invented us! Giving us the opportunity to let you relax while we invented everything else." —Wheatley, Portal 2
With UBI it won't be expensive anymore. So much of the economy is simply extractive, most people's jobs are really already highly algorithmic and involve much less "thinking" than they think. Being able to sit around and think has often been a historical luxury - of the elite or those lucky enough to be subsidized by them. I suppose the common (as they all were) man of prehistory also had more time to think, which was doubtless the germ of humanity's religious and speculative impulses. But they also had to contend with a brutal world where death was around every corner.
The economy doesn't want you to think. Knowledge workers really have far too high an opinion of themselves in this regard. Your "thinking" was merely more instrumentally useful than the alternatives. Most of us have done very well while inventing nothing. But an even better day dawns.
When humans don't have to rely on their own labor to survive, more humans will think. The opportunity to afford to indulge your curiosity as if you were among the wealthy and privileged. A society that can afford the Enlightenment and its myriad avenues at scale. What else will there be to do?
UBI is not going to be a thing, ever. The ogliarchs want every penny for themselves -they'll turn you into biofeul long before they give you a single penny they're not forced to.
This is one possibility, but it is not a given one. Being able to think will require capital. The whole problem here is will your thinking be worth anything and how will you feed yourself until the point it is.
Of course. You haven't really articulated a problem though. You've merely stated the obvious - the path from the present to a possible end state is not clear.
History teaches us changes for the good only happen after changes for the worse percolate deeply enough through the system. The idea that there will be hard times ahead is therefore not incompatible with my view at all, rather it is taken as a given.
Personally, I think the chances of most humanity surviving to the next century are already pretty slim (AI only marginally increases the chances of the worst case here imo). Hitler was not that far from a nuclear weapon. Our collective capacity for terror and self-destruction has only increased since 1945, while the lessons that have held the world together since increasingly fade. I have found it amusing to note that the demonization of AI has come with an accompanying valorization of human judgment as if all the evils of the world have heretofore not been the proud acts of some human somewhere, often with throngs of fellow humans in support.
Whereas, AI increasingly offers a chance that the best case (UBI, human survival through the next century), however unlikely in totality, is still far more likely than without it.
You are not incorrect. I am merely endeavoring to be optimistic. If only for the self-interested reason that I need to be able to sleep.
It helps to be optimistic I think, even if accompanied with a wry acknowledgement of futility. The future has always been frightening.
> History teaches us changes for the good only happen after changes for the worse percolate deeply enough through the system. T
Where do you get that from? History teaches us that only when changes for the worse are so severe that the elites' heads start rolling, will change for good come.
> The idea that there will be hard times ahead is therefore not incompatible with my view at all, rather it is taken as a given.
It's a tautology, hence useless: there will be hard times ahead, followed by good times is always a tautology. What we're concerned about is if the hard times last 10 years or 10000 years.
After all saying "the idea that there will be hard times ahead" is not incompatible with your view, and is also not incompatible with the view "the idea that there will be good times ahead".
There are a 163 million working adults in the US. Giving each of them $10k a year is already 2 trillion dollars. And $10k is not going to allow anyone to retire.
UBI is pure fantasy, tantamount to the rapture for AI bros.
Right. I'm sure that the real reason for extracting more profits at the expense of labour is to give it back to people without getting any labour in return.
At work, all thinking has basically become discouraged.
If you are not using AI agents for everything, you're doing something wrong, and wasting company time. It has been emphasized that no one should be writing code by hand and if you think an AI has implemented something wrong you need solid reasoning to show why or else people just label you as some anti-AI troublemaker, who just becomes an obstacle standing in the way of things getting done.
If your human generated opinion is in any way wrong or simply not a true homerun then you get snubbed in future reviews, people stop listening to you.
> and if you think an AI has implemented something wrong you need solid reasoning to show why or else people just label you as some anti-AI troublemaker,
I'm going to read you charitably, and assume that what you really meant is "the burden of proof is entirely on you, and is set unreasonably high." Because of course, if you do think someone has done something wrong and want to say it publicly, you do need a solid reason.
I saw a post on here, basically they get ai to design the change and give them each each one at a time that they manually type in.
They argued this still allowed them to fully understand what has being implemented and how it fitted together.
I’ve been doing this since I read that and it also allows you to catch stupid stuff while your typing, you can reason about what each little change does and why it’s needed.
This also lets the LLM change the future of the plan if you fine something.
This turns out to save a whole bunch of time later because you already know how it works.
It’s not nearly as fast as just letting the agent do everything.
I have been thinking about trying this approach. We really need something that's in-between, right? There's going to be code that is boilerplate implementation, and I don't need to drive that - like we have, in the before times, relied on macros and what not to do that work. But then the interesting logic, seeing the suggested implementation, copying or working from that. That's the sweet spot.
I've also been thinking about the partner programming craze phase our industry went through. I write the test, you write the code; well I write the test, LLM satisfies with code. (Then we have less of these weird LLM generated test cases that test _nothing_. We can also use the LLM to suggest tests to complete coverage.)
These would be slower to work this way, but the end result is:
1. humans still learn
2. you have a good grounding in how everything has been written
And more than anything, it doesn't take away the trade-offs of what to build to deliver value for customers, what to make the business improve, what avoids paging you on a vacation.
God help me, my manager (product director) has taken this approach for product strategy docs. Everything has become very stupid and extremely shallow. It’s easier than ever to coast, but man.. that’s not really what I wanted.
Huh, I don't use AI much/or at all anywhere, apart from googling something and reading the Gemini answer before scrolling down, without facing any backlash. Though people are more likely to discuss and brainstorm their work/problems with me because of this, which I consider a positive. Maybe I've been lucky at where I work.
That is if I ignore the slop MRs with 60+ files changed that I have to painstakingly go through and then politely tell the author to fix the crater sized holes in it, while a vein in my forehead almost explodes. And some part of my sanity is lost forever.
Free-thinking, critical thinking, has been considered taboo, or an exclusive privilege of the elite, in most human societies since the dawn of civilization.
I'm struggling with this with an open source project I work on (that has users). I have a port that passes all the tests, but there's enough code that it's hard to review that the LLM didn't change implicit design decisions or implement things in an unmaintainble way. It not clear to me how to build confidence to switch over and implement new stuff and leave the old one behind.
Yes, you certainly still do have to think. But you’re thinking about how to isolate risk via architecture and about which languages the AI can most naturally work in for a given task.
You’re thinking: Should I put a protobuf here and build a separate service? Which side should own the protocol? How do I ensure the AI never couples concerns A and B? Can we prove this works with smarter automated testing, or do we need additional manual QA in this critical area before release?
Port my whole legacy codebase to another language with no guidance is a novelty problem. It is not comparable to what professionally managed AI driven development actually looks like.
LLMs produce code faster than humans are able to check it. Today's systems are able to generate thousands of lines of code per day, no human team would be able to keep up with them. The problem, in my opinion, is the way LLMs are used. An LLM reasons and makes mistakes according to the logic it was created with, but different LLMs reason and make mistakes in different ways. I'll give an example: take 2 black boxes, each one with 2 inputs and 1 output. Inside, the boxes work in a different way: with the same inputs the outputs are different. The real key is to use the method of adversarial development: this reduces to a minimum (even if it doesn't eliminate completely) the possibility of errors. So to humans the task of checking the output, and to have quality output you need to spend, and a lot, at least 2 frontier LLMs. But the question is: is quality as a goal an expense or an investment?
"Quality", as you're referring to it, is often a strict requirement expected and enforced by regulation and contracts.
In the past, I could have just easily said that there's more code out there online than I could ever hope to write. There's simply no value in gluing that code together mindlessly or even probabilistically. All the value of code is in gluing it together intentionally as an organization. The value is in knowing the precise results including all side effects.
Let's call this type of AI development what it really is. It's an attempt to jiggle the wrong key in the door. You're trying to circumvent existing standards for profit and then launder blame for it.
Informative thought process here. Pre-committing benchmarks to measure real efficiency gains might have helped, but hands-off complex rewrites are still not shovel ready.
> hands-off complex rewrites are still not shovel ready
...which is a bit disappointing, actually. I mean, if you give an AI agent the complete code for a working application (ideally including tests), it should be able to translate it into an equivalent application in another language. I can understand if it makes mistakes because of ambiguous or incomplete prompts etc., but for this task you shouldn't even need a prompt, any information it might need is right there in the code?
Agreed. You would expect this to be a task that AI has a massive advantage over humans as it has both the testing suite to keep it on track and has the source implementation to reference. The classic failure case for agents is that as the task increases in complexity, it requires more steps to complete. With each step there's a chance for error. As errors accumulate, they become more likely. With verification functions, like test suites or comparison to some source, the agent is more likely to catch errors and recover.
So porting should be perfect conditions for an AI agent. It has the testing suite. It has the original implementation. Hell, it can A/B the original with its working copy and attach the original to a debugger.
So yeah I dunno. I guess despite some people's rhetoric on this site we shouldn't underestimate how difficult these tasks are "in the real world" (as opposed to like a game port which doesn't have real money on the line so far). And it is kind of a miracle these tools can even get in the ballpark and fool a lot of people.
Yes I have just started dabbling in some harness evals where the task is translating the RealWorld “mother of all demos” app, maybe one of the most translated apps of all time, and they cannot reliably 100% it
If it were me, I would start by getting a summary of what problems the existing solution solves. I would also make sure that summary had the non-functional requirement. Maybe write a test suite that opens the page and does all the stuff.
Then ask the LLM to implement in another language, with those solutions in mind, but first coming up with reasons why the target language might not be as good, and where it might have useful features that the original language didn't. Use the test suite to check if things are working.
I honestly don't think you would land far away. You would have to answer a few questions along the way, but it would mostly be plain sailing.
I would expect to be able to do this with very little human attention, whereas a language rewrite two years ago might take a whole month, not including learning the new language.
These articles IMO suffer from good data. It seems we could probably at this point study open source projects longitudinally and see what we learn depending on their AI policies. Are there patterns in stability? Bugginess? Performance? Readability? Etc.
came here looking for someone to point this out. the flip from "it's more fun to be competent" to "just let the machine do it for you" has told me everything I ever need to know about DHH. The man has no principles.
My suspicion is DHH is intentionally creating controversy to drive interest to Omarchy
If he truly believed in the idea of never reading the code, he'd fire all his developers and have the designers do it all - create very high level feature descriptions and iterate on them. Put your money where your mouth is
"Not reading the code" does not mean not knowing what the code should do, or how to probe it for correctness. Getting good outcomes from AI-generated code requires knowing exactly what to do.
I think he said the agents couldn’t make features in their existing codebases as well as in new ones, so he needed devs to still work on Basecamp. Maybe that has changed.
> If you want a reliable system you should know when to fail
I think the main problem is that most people pushing for heavy AI delegation either
1. Don’t really care about system reliability or
2. Don’t understand the difference between code and system, and assume that a system must be reliable if some automated checks pass
"If you looked at the code, and yeah, I know, we should not be reading code anymore"
I'm pretty sure this is sarcasm, but it's also a major factor in what differentiated slop from non-slop AI work: did a developer actually take the time to review and clean up generated code. Which is, itself, an extremely time consuming process
When you read the article you’ll see it gives numerous examples. Eg “The Rust version doesn't maintain 100% backwards compatibility, for example it drops the CSRF token so that caching is easier”
This particular quote doesn't make any sense. This is not what "backward compatibility" means. Is there a bug or does it just do thing differently so benchmark is not "fair"?
This post resonates a lot with me and my approach to counter the idea that an LLM (as amazing as a tool it is) gives programmers permission to stop engineering. To me, executing a decision in the face of trade-offs is what the job is all about.
So, I want to keep pulling the thread: is it worth reading—meaning, understanding—the code in order to prevent p95 latency from skyrocketing, avoid OOM death, and keep our apps reliable for customers?
The cost of understanding the code is ostensibly very high relative to just using a clanker (citation needed), so does paying that cost translate to value—what is it worth? Concretely, if vibe coding increases bugs and enshittification, but decreases spending without decreasing revenue (read: customers suffer, but they don't leave), do we still need to pay the cost of reading code? Is it better to invest in stickiness, lobbying, and market capture?
This comment shouldn't be read as advocating for this; it's a thought experiment about pragmatism and trade-offs, and reflects what I'm witnessing companies (and "programmers") asking themselves. I personally care a lot about understanding systems and code, and I believe I'm paid to do exactly that (I very much enjoy understanding code and nobody is paying me to run a business, so I may be biased in this). In everyday SaaS-land—not talking about critical safety systems—we've seen production databases destroyed, personal data leaked, platforms unwittingly exploited, and UX bugs creep into our operating systems, and yet the companies involved keep on keeping on.
Is thinking, meaning taking the time to actually understand what our systems are doing, going to increase their shareholder value?
> (read: customers suffer, but they don't leave), do we still need to pay the cost of reading code? Is it better to invest in stickiness, lobbying, and market capture?
Translating this from Linkedin-speak: Is it okay to subject our users to shitty software and while we use the money saved to bribe politicians, circumvent laws and buy our competitors to kill them?
I feel like the AI debate is our last best chance to agree that human values are more important and have higher long-term utility (to humans) than pure financial maximization. I think it’s very very likely that money does not capture or convert to a large subset of morally good choices we can and should make to be happy.
I agree. I'm using AI on a mid-complexity system (IoT devices, encryption, concurrency, etc) and the number of errors / bad decisions taken "at first" by the AI (or if I don't guide it precisely enough) is huge, and I can only imagine how feeble and unmaintainable an entire codebase done without review from a senior coder would be
I think attempting few-shot agentic ports of an app as an exercise and having the results not be perfect is really a referendum on thinking or using AI in coding in any particularly meaningful way.
The quality of anything is proportional to the time people spend paying attention to quality measures they care about. If you care about the quality of the code (and I am extremely bimodal about when I do and do not), then spending time looking at the code, whether said code is written by a clanker or a coworker, will lead to tinkering with and improving it. If you care about UI functionality, and you spend time tweaking the UI functionality, then it will get better. If you care about performance, and you spend time measuring, displaying, improving, it will get better.
Clanker code is no exception. Slop is slop because it's low effort.
There are projects I've put most of my career into (necessarily pre-AI), and those I definitely care about the code quality. I look at every line and I don't take clanker code without going around the mill a few times with it. There are lots of things in the code I like and things I don't like and want to refactor. I care about the code quality. But there are projects I've put only weeks or month into, and some only minutes. For most of my vibe-coded projects, I've only cursorily glanced at the code. For these projects I don't care about code quality as much as the architecture and interaction. The ones where I consistently tweak it to work how I want are...just better.
For me it’s a strong indicator that we’re not going to hear any serious thought from someone that uses it. It’s part of a herd behavior, to signal an ideological position.
It’s ideological in that it’s generally used by people that are anti-AI, or are trying to call out some perceived problem with AI.
In my experience, as I alluded to, it’s not commonly used by people who are thinking seriously for themselves about the benefits, risks, and consequences of AI and the economic activity surrounding it.
That article only confirms what I’m saying. The author is describing their personal perspective on the word, but that’s not how it’s used in general, which is why the author received pushback on their undocumented and idiosyncratic usage.
I dunno. You still have to test, but in my experience if I noticed unreliability during high load I could just tell Claude "I noticed unreliability during high load" and it would easily have set up a high load benchmark, discovered this broadcast channel issue and fixed it.
It definitely improves the results if you do think but I don't think "you still have to think" is a safe space that's going to save us from unemployment.
Author is saying that some decisions aren't as obvious as "my code should be reliable under high load". Some decisions are tradeoffs that require you to have domain/technical expertise to answer.
And some do require design thinking. Like sndio or alsa, drm, caddy, … With no domain expertise and technical knowledge, a lot of software are out of scope.
> It definitely improves the results if you do think but I don't think "you still have to think" is a safe space that's going to save us from unemployment.
Who said anything about saving people from unemployment?
> I noticed unreliability during high load
This is pretty ambiguous. You still need to provide more context, such as which failure modes you are trying to benchmark.
(in Homer Simpson voice) You still have to think... so far!
But let's face it. I'm calling it right now: these are the twilight days of the "hacker culture". It's gotten us this far, and given us great things like Linux and the internet. But frontier models are already capable of solving medium-sized engineering problems in reasonable ways, including all the architectural decisions. You still need a few people with engineering chops, perhaps principal level or systems engineers, to guide the overall architecture of the system as a whole and make sure the pieces the LLMs build align and fit together correctly. Within a year or two, not even they will be needed. We're already past the threshold beyond which careful human review of LLM-generated code is impractical; the LLM spews it out so quickly that the human becomes the bottleneck, and reviewing all that code is more tedious and time-consuming than if a human had reviewed it in the first place! So the most efficient thing is for agentic loops to separately generate and scrutinize the code, with the generators and critics not sharing a context window.
Hackers are obsolete. Whether you're talking about the Richard Stallman variety or the Kevin Mitnick variety. Everything they do, a machine will be able to do presently, if it is not already. And the machine will be faster and more thorough. The suits and marketroids they viewed with such disdain, have won. They have been trying to build software factories since the 1970s. That dream is within reach. Our skills, traditions, and lore are being replaced with a sort of goetic demonology: knowledge about this month's correct way to invoke the demon, command it so it will do what you want, and bind it so it doesn't escape the circle cast on the floor and delete your production database.
And it's not just programming. Mathematics has already fallen; the hard sciences will too on a time horizon of about 10-15 years tops. Anthropic is setting up a wet lab; the biologists therein will pretty much act as peripherals to Claude, who will devise the experiments and analyze the data. As soon as we give the LLMs robot bodies, it will be needless—and woefully inefficient—for humans to invent anything at all. We're accelerating towards something. Whether it's Iain M. Banks's Culture or utter disaster I'm not sure which, but there's no stopping the train now.
I feel a bit sad DHH did the elixir one so dirty. It's the only language with the rule to follow rails to the T and of course Elixir can fly and be incredibly powerful without redis and other bullshit. It feels deliberately hamstrung. Almost maliciously because heavy hitters like Jose Valim have told him about this and he just ignores it.
All that requires _effort_. A stunt where you AI-translate a library into multiple languages is clearly not a context where you'll see that kind of effort applied.
"I didn't do anything. I asked two frontier agents to make the most of Elixir and this is what they came up with. Please do send a PR to speed things up! But also realize that it's not exactly extra points for Elixir if frontier agents can't find the magic "go fast" switches."
>This is because a whole lot of questions don't have a single correct answer. Do we want to keep backwards compatibility? Do we care more about latency or throughput? How much memory can the system use under load? Is loosing new content notifications after a crash acceptable?
This hasn't been the case for months now. In Codex, if the model is having trouble understanding what you meant, it will ask you followup questions before going ahead.
I have personally encountered GPT-6 Astra ask these exact questions before proceeding!
Like most criticism of AI, this is woefully outdated.
One of the worst things you can do is pull punches when you get "contributions" that are net-negative because they waste everyone's time.
You can do this in a professional way but still get the point across that they're stealing productivity from others that have to pull up their slack.
If the commits are too big or too dense. Make them break it up, clean up the comments etc. Otherwise they are simply doing a poor job. Not Claude, them.
Can’t have the cake and eat it too.
If they “solve” navier stokes and mathematics, they surely should be able figure such menial tasks out on their own, shouldn’t they?
But it’s the fat part of the bell curve. There’s loads of even worse crap outside corporate code…and at the right end of the bell curve is deeply thought out and the result of long-term maintenance that tends towards as bulletproof as can be possible in this universe, parts of OSes, networking stacks, clocks, and the like.
It’s only because that stuff is so robust and sufficiently general that the rest of the world’s steaming pile of code works at all.
I don't know if I've worked on your bank's app (safe bet is I haven't), but I have worked on some banks' apps and... oh boy. Let's just say that if you've seen what I've seen, "stuff it into a mattress" starts looking like a sound financial policy.
It takes effort to debunk because you have to holistically consider what the problem was and actually find the better solution to prove why it’s lacking.
In other words, to debunk it, you have to do the actual work that wasn’t done the first time.
Some people may argue “so what?”
And to that I would just respond that the fast solution implies nobody probably thought about it, which is always risky and generally leads to very bad outcomes. If for no other reason than there is at least no consensus, which for long-term software evolution is deeply problematic.
This has happened many times since this trend has started, and forcing everyone to step back after a year objectively reveals the murder that has been committed that, believe it or not, is not trivially unwound.
In the wrong hands it’s a debt machine that is already killing companies from the inside.
Also, now people who used to manage the development but not write any code also feel their superpowers to merge LLM slop in humongous amounts. It feels like a ticking time bomb, but I am afraid of calling it out and rain on their parade of 10x productivity (or often AI psychosis). Leaving the team doesn't feel like a good decision because what I hear from many colleagues is much worse. Ah what a time to be alive...
Really you're just asking for manual or automated performance tests (and you might be requesting different criteria than some already provided)
Then respond with that addressed, with a firm but polite explanation that the document has some problems that need to be addressed carefully before we invest time on it.
None of this works if it’s coming from your boss, but it’s very effective at making people think twice before sending you slop.
People only do the workslop thing when they believe the benefits of showing the work outweigh the reputational risks. If they get caught every time they do it and exposed on an email chain, they start doing less.
BUT because it is AI it's not that section that's addressed, it's about 90% of the document that now has changed, and I need to spend another gargantuan effort to review it. It's like by trying to be helpful I actually lose more time.
The AI has made it so that the thinking before writing is mostly gone, and shifted that step to the reviewers.
Now, no matter the amount of preparation work, those last rounds can completely rewrite something with no hope of review. No iterative improvement. No ratcheting towards a known quality. Just a bunch of cargo cult review followed by YOLO-style, vibe-everything absurdity.
The ratio of verification capacity to generation capacity, V/G, has broken with LLMs. It’s not simply an issue of more generation or less review.
The impression seems to be that individuals are more productive, but that productivity is someone else’s review burden. So the team/firm as a whole is not better off.
The cheap generation of content does mean that reviewer capacity is now a limited resource.
Unless your firm is aware and is measuring time spent on reviewing slop, there is no incentive or structure to ensure that time is respected and valued.
This is a management and awareness problem since the typical response is “use a bot to review it.”
Not to say these proofs are slop, even if the LLM-generated work is of good quality, what happens when no one knows how it works anymore ? Even if you ask the LLM to explain, which it does quite badly, the time to understand the explanation is incompressible.
So in the end, productivity will probably reach a ceiling that we can estimate as the product of humans, their cognitive capacity and their time. And that ceiling may be lower than what AI companies valuation expect, regardless of the compute and they can pump out and the RSI level they can reach.
Presentation layer code doesn't control how the machine and kernel prioritize anything; so "proof" Ruby code is doing the right thing is proving the machine does the right thing from the factory.
As for abstract theory and math, well shit since any English and any math are...mathematically possible...well shit I guess we gonna have to live in the real world and not inside a rhetorical bubble; religious or atheist philosophy... cause they are not evenly distributed frameworks as religion clearly shows; so why live by the syntax and semantics of some mathematical rando who taught a stats class years ago?
Same shit as living by religious allegory
Goodhart's Law has come for 1900s means of scientific inquiry; every technology follows an S-curve and the same for every social society. In the US we aren't all defaulting to calling ourselves British or speaking Latin.
Physics will always be there. The stupid glyphs and bird song we came up with to communicate about it isn't physics. It's just a human language system.
Performance issues in code just need an LLM now
I have to ask. Did you even skim the article you’re commenting under?
None of which have much to do with how the hardware handles requests.
Am an EE with a background in applied physics and well aware we could jam a kernel in the BIOS/UEFI storage and generate the runtime state around it at boot from a prompt cause I am working on just that
Which is exactly where we are headed with Jev/decision models; they can generate new config to min/maxing per process resource use; look into bpf and sched_ext and meditate on their application. It should eventually jump out at you
We have known in the abstract how to handle computing efficiently on our machines since we started building transistor based machines
It doesn't require handing a bunch of meat suits verbose languages/bloated state machines to manually tweak the parameters of and make mess of electrical state management
Writing code is not high tech. It's 1970s and 1980s tech. As this forum should be well aware tech evolves with the times.
The coder bros refusal to move on is them clinging to a sunk cost fallacy; but they already put time and $$ into their education in ugly languages and DSLs that merely initialize values in memory and ask the hardware to run it within some spacetime constraints
The syntactic gibberish is just a barnacle of a bygone era
Social web addicted Millennials need to grow up and move on
That said, I don't know if it matters at this point.... On top of Brandolini's law (mentioned elsewhere), what's more likely to happen is that developers' intellect, made available in open source, is just going to be harvested as context for different projects (I'm not taking about training data, I'm taking about devs literally cloning repos into an agent to harvest intellect).
You do still have to think, but you have to think about how to reorganize code in a way that allows AI to succeed.
This is not a great way to showcase the capabilities of this technology.
In some cases you can get away with not reading the code. And maybe in the future that will be more common. But for now, I personally prefer to read (or skim) the code, and not abdicate to AI.
He favorite axe to grind was how my generation put too much trust into the compiler. "Just because it compiles doesn't mean you're done. You need to look at the actual assembly. Compilers can be VERY inefficient."
This was in the 90s. There was some merit to his claim.
But today? How many people who write Javascript look at the actual assembly code that is run? Not many.
I can't help but wonder if this current "you need to understand the code" is the same thing all over again. And if in a few years, almost nobody will look at the generated Python, Ruby, etc.
They don't look but they should.
If we are going to the moon, then by all means I think we should probably scrutinize every single line of code, but most business aren't going to the moon.
If I'm tired, yep I'm going to write more sloppy code, I'll put less thought into it and be more tempted to tell the AI 'just do it'. That hasn't changed. I'm not sure where this new breed of "don't read the code" is coming from when it's actual software engineers making the statement; maybe it's just over-excitement and it'll die down (hopefully).
Or it's just over-simplification -- I don't read ALL the code either anymore, but at the same time I'm reading SOME of the code. Tell your AI agent you're doing a code review workshop, ask it to select ten files at random and then go through them with you one at a time. Ask it to review common anti-patterns and put them in your coding standard. Then you can start asking it to review and fix code against your standard as a first pass. You'll still need to manually review the code to keep it in check, but at least you can make it a bit less daunting and a little more fun by actively collaborating on the AI with the review.
I'm learning it's just a 'different kind of tired'. AI has made some stuff much more efficient, including the choice between efficiency and carefulness. You can make that choice at a micro level and very quickly now if you want. There's still fatigue though, it's just a different kind of fatigue. You still get tired from all the thinking. You can still choose to put the work in or not and it still makes a difference. It's just a different kind of difficult. Doesn't mean that the thing to do is to throw your hands in the air and declare that your job shouldn't be difficult or include hard work anymore.
if your prompt is not specific enough, many decisions are a coin flip.
If you are using AI, you still have to know what you want it to do. If you are a project manager and give your team incomplete requirements, the result may not be unlike this.
Also practically it’s not a good way of seeing it. It would aim for the average solution of the problem which might not what you need, but its not a coin flip.
Idk these kind of sentences just stink to me.
remember this timeless Agent Smith quote
"I just realized another great thing about humans: You invented us! Giving us the opportunity to let you relax while we invented everything else." —Wheatley, Portal 2
With UBI it won't be expensive anymore. So much of the economy is simply extractive, most people's jobs are really already highly algorithmic and involve much less "thinking" than they think. Being able to sit around and think has often been a historical luxury - of the elite or those lucky enough to be subsidized by them. I suppose the common (as they all were) man of prehistory also had more time to think, which was doubtless the germ of humanity's religious and speculative impulses. But they also had to contend with a brutal world where death was around every corner.
The economy doesn't want you to think. Knowledge workers really have far too high an opinion of themselves in this regard. Your "thinking" was merely more instrumentally useful than the alternatives. Most of us have done very well while inventing nothing. But an even better day dawns.
When humans don't have to rely on their own labor to survive, more humans will think. The opportunity to afford to indulge your curiosity as if you were among the wealthy and privileged. A society that can afford the Enlightenment and its myriad avenues at scale. What else will there be to do?
History teaches us changes for the good only happen after changes for the worse percolate deeply enough through the system. The idea that there will be hard times ahead is therefore not incompatible with my view at all, rather it is taken as a given.
Personally, I think the chances of most humanity surviving to the next century are already pretty slim (AI only marginally increases the chances of the worst case here imo). Hitler was not that far from a nuclear weapon. Our collective capacity for terror and self-destruction has only increased since 1945, while the lessons that have held the world together since increasingly fade. I have found it amusing to note that the demonization of AI has come with an accompanying valorization of human judgment as if all the evils of the world have heretofore not been the proud acts of some human somewhere, often with throngs of fellow humans in support.
Whereas, AI increasingly offers a chance that the best case (UBI, human survival through the next century), however unlikely in totality, is still far more likely than without it.
You are not incorrect. I am merely endeavoring to be optimistic. If only for the self-interested reason that I need to be able to sleep.
It helps to be optimistic I think, even if accompanied with a wry acknowledgement of futility. The future has always been frightening.
I wish you good fortune in the wars to come.
Where do you get that from? History teaches us that only when changes for the worse are so severe that the elites' heads start rolling, will change for good come.
> The idea that there will be hard times ahead is therefore not incompatible with my view at all, rather it is taken as a given.
It's a tautology, hence useless: there will be hard times ahead, followed by good times is always a tautology. What we're concerned about is if the hard times last 10 years or 10000 years.
After all saying "the idea that there will be hard times ahead" is not incompatible with your view, and is also not incompatible with the view "the idea that there will be good times ahead".
UBI is pure fantasy, tantamount to the rapture for AI bros.
Not without a lot of bloodshed and public beheadings, if history is any indication about changes benefiting the labour class.
Right. I'm sure that the real reason for extracting more profits at the expense of labour is to give it back to people without getting any labour in return.
That makes perfect sense.
/s
If you are not using AI agents for everything, you're doing something wrong, and wasting company time. It has been emphasized that no one should be writing code by hand and if you think an AI has implemented something wrong you need solid reasoning to show why or else people just label you as some anti-AI troublemaker, who just becomes an obstacle standing in the way of things getting done.
If your human generated opinion is in any way wrong or simply not a true homerun then you get snubbed in future reviews, people stop listening to you.
I'm going to read you charitably, and assume that what you really meant is "the burden of proof is entirely on you, and is set unreasonably high." Because of course, if you do think someone has done something wrong and want to say it publicly, you do need a solid reason.
I'm curious how explicitly this is put -both in your case, and in general. Do they frame it that way, or is it more passive-aggressive?
However, it doesn't take away the concern of architecture, design, etc. and questioning if the current solution is well designed or not.
In other words, if you can't question the AI and refute it in a topic, you aren't expert enough to use AI in that area in a engineering manner.
Granted, not everything needs an engineer behind it. A shack to store some tools will survive long enough probably
They argued this still allowed them to fully understand what has being implemented and how it fitted together.
I’ve been doing this since I read that and it also allows you to catch stupid stuff while your typing, you can reason about what each little change does and why it’s needed.
This also lets the LLM change the future of the plan if you fine something.
This turns out to save a whole bunch of time later because you already know how it works.
It’s not nearly as fast as just letting the agent do everything.
I've also been thinking about the partner programming craze phase our industry went through. I write the test, you write the code; well I write the test, LLM satisfies with code. (Then we have less of these weird LLM generated test cases that test _nothing_. We can also use the LLM to suggest tests to complete coverage.)
These would be slower to work this way, but the end result is:
1. humans still learn 2. you have a good grounding in how everything has been written
That is if I ignore the slop MRs with 60+ files changed that I have to painstakingly go through and then politely tell the author to fix the crater sized holes in it, while a vein in my forehead almost explodes. And some part of my sanity is lost forever.
It's easy to port a codebase (at least, if you have automated tests), but once you've done that, do you
- Implement features in the old code and port again?
- Implement them in the new, unfamiliar codebase?
- Just write a Jira ticket and let the agent YOLO it?
You’re thinking: Should I put a protobuf here and build a separate service? Which side should own the protocol? How do I ensure the AI never couples concerns A and B? Can we prove this works with smarter automated testing, or do we need additional manual QA in this critical area before release?
Port my whole legacy codebase to another language with no guidance is a novelty problem. It is not comparable to what professionally managed AI driven development actually looks like.
In the past, I could have just easily said that there's more code out there online than I could ever hope to write. There's simply no value in gluing that code together mindlessly or even probabilistically. All the value of code is in gluing it together intentionally as an organization. The value is in knowing the precise results including all side effects.
Let's call this type of AI development what it really is. It's an attempt to jiggle the wrong key in the door. You're trying to circumvent existing standards for profit and then launder blame for it.
...which is a bit disappointing, actually. I mean, if you give an AI agent the complete code for a working application (ideally including tests), it should be able to translate it into an equivalent application in another language. I can understand if it makes mistakes because of ambiguous or incomplete prompts etc., but for this task you shouldn't even need a prompt, any information it might need is right there in the code?
So porting should be perfect conditions for an AI agent. It has the testing suite. It has the original implementation. Hell, it can A/B the original with its working copy and attach the original to a debugger.
So yeah I dunno. I guess despite some people's rhetoric on this site we shouldn't underestimate how difficult these tasks are "in the real world" (as opposed to like a game port which doesn't have real money on the line so far). And it is kind of a miracle these tools can even get in the ballpark and fool a lot of people.
If it were me, I would start by getting a summary of what problems the existing solution solves. I would also make sure that summary had the non-functional requirement. Maybe write a test suite that opens the page and does all the stuff.
Then ask the LLM to implement in another language, with those solutions in mind, but first coming up with reasons why the target language might not be as good, and where it might have useful features that the original language didn't. Use the test suite to check if things are working.
I honestly don't think you would land far away. You would have to answer a few questions along the way, but it would mostly be plain sailing.
I would expect to be able to do this with very little human attention, whereas a language rewrite two years ago might take a whole month, not including learning the new language.
https://arxiv.org/abs/2507.09089
If he truly believed in the idea of never reading the code, he'd fire all his developers and have the designers do it all - create very high level feature descriptions and iterate on them. Put your money where your mouth is
I think the main problem is that most people pushing for heavy AI delegation either
1. Don’t really care about system reliability or 2. Don’t understand the difference between code and system, and assume that a system must be reliable if some automated checks pass
I'm pretty sure this is sarcasm, but it's also a major factor in what differentiated slop from non-slop AI work: did a developer actually take the time to review and clean up generated code. Which is, itself, an extremely time consuming process
We got strictly better version of application for cheap. What is there even to complain about?
Life, eh?
So, I want to keep pulling the thread: is it worth reading—meaning, understanding—the code in order to prevent p95 latency from skyrocketing, avoid OOM death, and keep our apps reliable for customers?
The cost of understanding the code is ostensibly very high relative to just using a clanker (citation needed), so does paying that cost translate to value—what is it worth? Concretely, if vibe coding increases bugs and enshittification, but decreases spending without decreasing revenue (read: customers suffer, but they don't leave), do we still need to pay the cost of reading code? Is it better to invest in stickiness, lobbying, and market capture?
This comment shouldn't be read as advocating for this; it's a thought experiment about pragmatism and trade-offs, and reflects what I'm witnessing companies (and "programmers") asking themselves. I personally care a lot about understanding systems and code, and I believe I'm paid to do exactly that (I very much enjoy understanding code and nobody is paying me to run a business, so I may be biased in this). In everyday SaaS-land—not talking about critical safety systems—we've seen production databases destroyed, personal data leaked, platforms unwittingly exploited, and UX bugs creep into our operating systems, and yet the companies involved keep on keeping on.
Is thinking, meaning taking the time to actually understand what our systems are doing, going to increase their shareholder value?
Translating this from Linkedin-speak: Is it okay to subject our users to shitty software and while we use the money saved to bribe politicians, circumvent laws and buy our competitors to kill them?
Clanker code is no exception. Slop is slop because it's low effort.
There are projects I've put most of my career into (necessarily pre-AI), and those I definitely care about the code quality. I look at every line and I don't take clanker code without going around the mill a few times with it. There are lots of things in the code I like and things I don't like and want to refactor. I care about the code quality. But there are projects I've put only weeks or month into, and some only minutes. For most of my vibe-coded projects, I've only cursorily glanced at the code. For these projects I don't care about code quality as much as the architecture and interaction. The ones where I consistently tweak it to work how I want are...just better.
[0] https://xkcd.com/1053/
In my experience, as I alluded to, it’s not commonly used by people who are thinking seriously for themselves about the benefits, risks, and consequences of AI and the economic activity surrounding it.
It's much more nuanced, after all. Example:
https://lucumr.pocoo.org/2026/5/26/clankers/
It definitely improves the results if you do think but I don't think "you still have to think" is a safe space that's going to save us from unemployment.
Who said anything about saving people from unemployment?
> I noticed unreliability during high load
This is pretty ambiguous. You still need to provide more context, such as which failure modes you are trying to benchmark.
But let's face it. I'm calling it right now: these are the twilight days of the "hacker culture". It's gotten us this far, and given us great things like Linux and the internet. But frontier models are already capable of solving medium-sized engineering problems in reasonable ways, including all the architectural decisions. You still need a few people with engineering chops, perhaps principal level or systems engineers, to guide the overall architecture of the system as a whole and make sure the pieces the LLMs build align and fit together correctly. Within a year or two, not even they will be needed. We're already past the threshold beyond which careful human review of LLM-generated code is impractical; the LLM spews it out so quickly that the human becomes the bottleneck, and reviewing all that code is more tedious and time-consuming than if a human had reviewed it in the first place! So the most efficient thing is for agentic loops to separately generate and scrutinize the code, with the generators and critics not sharing a context window.
Hackers are obsolete. Whether you're talking about the Richard Stallman variety or the Kevin Mitnick variety. Everything they do, a machine will be able to do presently, if it is not already. And the machine will be faster and more thorough. The suits and marketroids they viewed with such disdain, have won. They have been trying to build software factories since the 1970s. That dream is within reach. Our skills, traditions, and lore are being replaced with a sort of goetic demonology: knowledge about this month's correct way to invoke the demon, command it so it will do what you want, and bind it so it doesn't escape the circle cast on the floor and delete your production database.
And it's not just programming. Mathematics has already fallen; the hard sciences will too on a time horizon of about 10-15 years tops. Anthropic is setting up a wet lab; the biologists therein will pretty much act as peripherals to Claude, who will devise the experiments and analyze the data. As soon as we give the LLMs robot bodies, it will be needless—and woefully inefficient—for humans to invent anything at all. We're accelerating towards something. Whether it's Iain M. Banks's Culture or utter disaster I'm not sure which, but there's no stopping the train now.
Not a good look tbh
"I didn't do anything. I asked two frontier agents to make the most of Elixir and this is what they came up with. Please do send a PR to speed things up! But also realize that it's not exactly extra points for Elixir if frontier agents can't find the magic "go fast" switches."
https://x.com/dhh/status/2106864061832991134
<astronaut always has been meme>
This hasn't been the case for months now. In Codex, if the model is having trouble understanding what you meant, it will ask you followup questions before going ahead.
I have personally encountered GPT-6 Astra ask these exact questions before proceeding!
Like most criticism of AI, this is woefully outdated.