Hacker News Reader

Comment by variety8675 | Hacker News Reader

This article just reminds me that workslop is so hard to counter because it takes no effort to produce and immense effort to debunk

View on HN

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...

Aka https://en.wikipedia.org/wiki/Brandolini%27s_law

Mark Twain is halfway around the world before Brandolini puts on his shoes.

That particular quote attribution is, literally, halfway around the world: https://quoteinvestigator.com/2014/07/13/truth/

This is why the adverse reaction must be proportional to the effort required to counter the destructive behavior. It must be strongly discouraged.

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.

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.

Sorry the corporate initiative is to use AI for that

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.

> 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?

I think it is appropriate to invoke 'in loco parentis' for this.

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...

Its the same as with luddites / textiles, people proved they were willing to accept far worse quality because "automation". People have a strange cognitive bias it seems. When they know a person has done something, the scrutinize and correct. When its a machine / automated, or the price is low enough, it gets hand-wavy.

People here often say "we can't set rules, because imagine how hard it would be to follow them at scale". That same strange cognitive bias applies here. Somehow the "push a magic button and it works" and "of course it can't do it just as well as a person every time" kind of take over.

Imagine if many tech issues like access to pornography, corporate ad tech, violent/racist material, AI slop, etc. were all just armies of people doing it (like google / X actually just had a person curate your results really fast for every search). Of course people would be outraged at the quality, but its "automated" so no one questions.

Similarly, if AI was just a giant outsourced coding firm with 10M programmers that could write you a slop app in an afternoon for $1, people would be complaining at how idiotic it is, and how inferior to regular devs. But instead, the "machine bias" takes over and people try to forgive the shortcomings.

there is something in the human psyche that badly wants to replace itself with a machine, despite it spelling our own undoing, and often resulting in worse outcomes along the way. I suppose the whole "make a tool" drive has been wildly successful overall, but this is probably the required downside to such an innate drive.

Like have you seen the 3d printed houses? They are the uggliest, shittiest houses in the world, but somehow the lure of "yes but we can build them in 24 hours" seems to somehow get people interested. If a human made one of those dung heaps they would be pillaried as a village idiot, and rightly mocked, but somehow because "machine do thing", we should get excited about excreted dung beehive houses...

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".

Illuminati propaganda!

MJ 12

There's a little bit of latitude to push back in code review. "Show me x,y,z you've collected before and after your change"

Really you're just asking for manual or automated performance tests (and you might be requesting different criteria than some already provided)

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.

Sounds like Claude. I haven’t made this experience with the large OpenAI models.

Honestly the mere possibility is undermining my trust in my colleagues.

Just ask an LLM to critique the work and send the response back.

Ive categorically stopped reading AI S2T meeting minutes.

I take notes, email out what is personally relevant, and put the burden on people to verify any rebuttal.

Honestly it goes far

I think the problem is AI meeting minutes use a template that forces a summary when it doesnt work. I found just taking the raw transcript and uploading to an LLM helps way more than using the teams summary.

Its been immensely helpful catching things I didn't understand the first time.

But you still need to pay attention in the meeting.

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.

Debunking can often be 'it runs but it's 100x slower than it should be'

I was responding to the "immense effort"

Performance issues in code just need an LLM now

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.

... Code can run but not correctly solve the business problem for which it was written, or it can run poorly, slowly, unreliably, etc

> This is about computer code. Debunking is either "it runs or doesn't". Not hard.

I have to ask. Did you even skim the article you’re commenting under?

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

> None of which have much to do with how the hardware handles requests.

How so?

Reply on news.ycombinator.com