> Classic procedural generation is noteworthy here as a precedent, which gamers were already familiar with, because by and large it has failed to deliver.

Yes, this is a wildly uneducated perspective.

Procedural generation has often been a key component of some incredibly successful, and even iconic games going back decades. Elite is a canonical example here, with its galaxies being procedurally generated. Powermonger, from Bulldog, likewise used fractal generation for its maps.

More recently, the prevalence of procedurally generated rogue-likes and Metroidvanias is another point against. Granted, people have got a bit bored of these now, but that's because there were so many of them, not because they were unsuccessful or "failed to deliver".

> Yeah, exactly. And LLM help developers save time from writing the same thing that has be done by other developers for a thousand times.

Before LLMs we did already have a way to "save developers time from writing the same thing that has been done by other developers for a thousand times", you know? A LLM doing the same thing the 1001st time is not code reuse. Code reuse is code reuse.

No, it's simply untrue. Players only object against AI art assets. And only when they're painfully obvious. No one cares about how the code is written.

This reminded me of a conversation about AI I had with an artist last year. She was furious and cursing and saying how awful it is for stealing from artists, but then admitted she uses it for writing descriptions and marketing posts to sell her art.

You're cherry picking. The open world games aren't as compelling anymore since the novelty is wearing off. I can cherry pick, too. For example, Starfield in all its grandeur is pretty boring.

And the users may not care about code directly, but they definitely do indirectly. The less optimized and more off-the-shelf solutions have seen a stark decrease in performance but allowing game development to be more approachable.

LLMs saving engineers and developers time is an unfounded claim because immediate results does not mean net positive. Actually, I'd argue that any software engineer worth their salt knows intimately that more immediate results is usually at the expense of long term sustainability.

Also "AI" has been in gaming, especially mobile gaming, for a literal decade already.

Household name game studios have had custom AI art asset tooling for a long time that can create art quickly, using their specific style.

AI is a tool and as Steve Jobs said, you can hold it wrong. It's like plastic surgery, you only notice the bad ones and object to them. An expert might detect the better jobs, but the regular folk don't know and for the most part don't care unless someone else tells them to care.

And then they go around blaming EVERYTHING as AI.

If you read the next couple of paragraphs, the author addresses this:

> That said, Steam's policy has been recently updated to exclude dev tools used for "efficiency gains", but which are not used to generate content presented to players.

I only quoted the first paragraph, but there is more.

One the topic procedural generation; rogue likes are all about it and new generation Diablo like games have definitely similar things, well respected new games like Blue Prince. There has never been such as successful period of time for procedural generation in games like now, and all of these are pre-AI. AI powered procedural generation is wet dream of rogue-like lovers

> No one cares about how the code is written.

I would overstate:

No one even cares how architecture is done. Unless you are the one fixing it or maintaining it.

Sorry, no one. We all know Apple did some great stuff with their code, but we care more about the awful work done on the UI, right? I mean - the UI seems to not be breaking in these new OSs which is amazing feature... for a game perhaps, and most likely the code is top notch. But we care about other things.

This is the reality, and the blind notion that so-many people care about code is super untrue. Perhaps someone putting money on developers care, but we have so many examples already of money put on implementation no matter what the code is. We can see everywhere funds thrown at obnoxious implementations, and particularly in large enterprises, that are only sustained by the weird ecosystem of white-collar jobs that sustains this impression.

Very few people care about the code in total, and this can be observed very easy, perhaps it can be proved no other way around is possible.

Also RE: procgen, one of the hit games right now, Mewgenics, is doing super well and uses it extensively. Obviously it's old school procgen that makes use of tons of authored content, but it's still procgen.

> Players only object against AI art assets. And only when they're painfully obvious.

Restaurant-goers only object against you spitting in their food if it's painfully obvious (i.e. they see you do it, or they taste it)

Players are buying your art. They are valuing it based on how you say you made it. They came down hard on asset-flipping shovelware before the rise of AI (where someone else made the art and you just shoved it together... and the combination didn't add up to much) and they come down hard on AI slop today, especially if you don't disclose it and you get caught.

> Spore is well acclaimed.

Spore was fun (IMHO) but at the time of release was considered a disappointment compared to its hype.

localization? Why would you oppose LLMs doing localization?

An LLM has never saved me time. It has always produced something that doesn't quite work, has the rough shape of what I want, but somehow always gets all the details wrong.

I can type up what I want much faster and be sure it's at least solving the right problem, even if it may have bugs.

There are also tools to generate boilerplate that work much much better than LLMs. And they're deterministic.

>No one cares about how the code is written.

People definitely do care. Nobody wants vibe-coded buggy slop code for their game.

They want well designed and optimized code that runs the game smoothly on reasonable hardware and without a bunch of bugs.

> Spore is well acclaimed

And yet it also effectively ended Will Wright's career. Rave press reviews are not a good indicator of anything, really.

> Yeah, exactly. And LLM help developers save time from writing the same thing that has be done by other developers for a thousand times. I don't know how one can spins this as a bad thing

Do you ever ask why you're writing the same thing over and over again? That's literally the foundational piece of being an engineer; understanding when you're reinventing the wheel when there's a perfectly good wheel nearby.

> I don't know how one can spins this as a bad thing.

People spin all kinds of things if they believe (accurately or not) that their livelihood is on the line. The knee-jerk "AI universally bad" movement seems just as absurd to me as the "AGI is already here" one.

> Spore is well acclaimed. Minecraft is literally the most sold game ever.

Counterpoint: Oblivion, one of the first high-profile games to use procedural terrain/landscape generation, seemed very soulless to me at the time.

As I see it, it's all a matter of how well it's executed. In the best case, a skilled artist uses automation to fill in mechanical rote work (in the same way that e.g. renaissance artists didn't make every single brushstroke of their masterpieces themselves).

In the worst (or maybe even average? time will tell) case, there are only minimal human-made artistic decisions flowing into a work and the output is a mediocre average of everything that's already been done before, which is then rightfully perceived as slop.

> What matters in the end is that this tech is not to empower a common person (although it could).

How do you figure? 20 dollars/month is insanely cheap for what OpenAI/Anthropic/Google offer. That absolutely qualifies as "empowering a common person". It lowers barriers!

A lot of the anti-AI sentiment on HN concerns people losing their jobs. I don't think this will happen: programmers who know what they're doing are going to be way, way more effective at using AIs to generate code than others.

But even if it is true and we do see job losses in tech: are software devs really "in a precarious position"? Do they really qualify as "those that have little"? Seems like a fantasy to me. Computer programmers have done great over the past 30 years.

More broadly, anti-AI sentiment comes from people who dislike change. It's hard to argue someone out of that position. You're allowed to prefer stasis. But the world moves on and I think it's best to remain optimistic, keep an open mind, and make the most of it.

> It is there to reduce our agency, to make it easier to fire us, to put us in even more precarious position

Could be. It could also end up freeing us from every commercial dependency we have. Write your own OS, your own mail app, design your own machinery to farm with.

It’s here, so I don’t know where you’re going with “I’m unhappy this is happening and someone should do something”

At some point, if most people lose their jobs, you have no market to sell your services to. So, either, new jobs have to be created in order to keep the capitalism machine running, or you have to provide for the needs of every human being from whatever you're doing with your AI. Otherwise, a lot of hungry people revolt and you have violence against these businesses.

I think new jobs will be created because AI is always limited by hardware and its current capabilities. Businesses, in order to compete, want to do things their competitors aren't currently doing. Those business needs always go beyond the current technological capabilities until the tech catches up and then they lather, rinse, repeat.

Demand full automation. Demand universal basic income. Notice how the later is nearly absent from the conversation.

Another distraction is AGI that which is a danger to humanity- the only danger is people...

I guess you didn't read the article?

Your comment made me think of the Japanese. They have a highly industrialised society, but they also value greatly hand-made products from food and clothes to woodwork and houses.

And they also like to emphasise how long it takes for someone to become a master at a given trade.

I think you are going to enjoy this talk by Jonathan Blow - Preventing the Collapse of Civilization:

https://www.youtube.com/watch?v=ZSRHeXYDLko

only code anyone will be touching in a museum in 800 years will be the good code. I hope they don't talk about what great craftsmen we all were because someone saw an original Fabrice Bellard at the Louvre.

Survivor bias plays a role in glorifying the past.

> Another interesting thing is that we do not know how they made them so fine. The technique was never recorded or documented in detail, as it was passed down from parent to child. So the knowledge is actually lost forever.

This is a rather extreme failure on their part. There’s nothing admirable about hoarding knowledge and forcing it to only be passed down in person.

I don’t see this as the Luddites being right at all because they were clearly incredibly wrong about their chosen method of knowledge storage. This was a highly predictable and preventable outcome. If we were talking about a company today that forgot how to manage their servers because they refused to document anything and only passed it down from person to person we wouldn’t be speaking in awe and wonder, we’d be rightly criticizing their terrible decision making.

That aside, every time I hear that knowledge has been lost forever it turns out to be an exaggeration from those trying to amplify the mystique of the past. If we wanted to make ultra-thin scarves we could do it. We could study those ultra thin museum pieces with our endless array of modern tools and then use our vast quantities of modern wool to experiment until we got something similar.

But you missed the reason why we wouldn’t want to: An ultra-thin scarf isn’t going to work as well as a thicker one for keeping someone warm. It will be less durable. It would be a fundamentally inferior product. It’s interesting to see as a museum antique that has to be treated with utmost delicacy, but not so much as a practical garment.

    luddites were right

I get there are many things happening today that are frustrating or moving some element of human life in negative or ambiguous directions, but we really have to keep perspective on these things.

Nearly every problem today is a problem with a solution.

The feelings of panic we have that things are going wrong are useful signals to help guide and motivate us to implement those solutions, but we really must avoid letting the doomerism dominate. Just because we hear constant negative news doesn't mean things are lost. Doesn't even mean things are bad.

It just means we have been hearing a lot of negative news.

This is what it looks like for progress to not be monotonically increasing.

I found that it normally takes one prompt early-on to go from 'vibe-coded spaghetti' to something having a decent architecture.

Before mass production, the women of the household would be forced to spend every free moment of their day, outside of their other work, making fabric.

Before mechanised farming, the men were forced to spend all day in the fields.

Never again.

> One of the claims of the Luddites is that quality would go down, because their craft took half a lifetime to master (it was passed down from parent to chile.)

Sounds like a tautology. If you deliberately hoard knowledge of course it’s going to be hard to obtain.

A big difference is cutting quality for the sake of mass production when it enables creating more necessities for people to live is a good thing. It is a good tradeoff. Cutting quality to make previously deterministic software more non deterministic does not improve anyones life except Sam Altman, Dario Amodei and the rest of the billionaire class.

I have no doubt in the future there will be a class of vibe software and it will be known as distinctly lower quality than human understood software. I do think the example you describe is a good use of vibing. I also think tech orgs mandating 100% LLM code generation are short sighted and stupid.

A lot of this push for “slop” is downstream of our K shaped economy. Give the people more money and quality becomes a lot more important. Give them less, and you’re selling to their boss who is often insulated from the effects of low quality.

You're right. Automation often trades quality for speed and quantity.

The difference between automating the creation of software and automating the creation of physical products is that software is everywhere. It is relied on for most tools and processes that keep our civilization alive. Cutting corners on that front, and deciding to entrust our collective future to tech bros and VC firms fiending for their next payout, seems like an incredibly dumb and risky proposition.

>the Luddites were right

The Luddites were right in the sense that the social order had changed in a negative way. In a careless way.

In the same way that we look at America now that has effectively put a plutocracy in absolute control of the country, at the same time that there is going to be a massive devaluing of labour. Elon Musk likes to talk about the coming golden age of automation, but I hope Americans realize that unless they happen to be a billionaire, they will enjoy zero fruits of that advance. Quite contrary, plump yourself up to be Soylent Green because it turns out that giving a bunch of psychopaths/sociopaths absolute control of government isn't good for the average person.

>One of the claims of the Luddites is that quality would go down

Then people will choose the better quality items and it will be easy for them to compete? Right?

Most of the people doing the most rote and monotonous work were and are doing so in some of the least productive circumstances, with clear ways of increasing speed and productivity.

If development velocity was truly an important factor in these businesses, we'd migrated away from that gang of four ass Java 8 codebase, given these poor souls offices, or at least cubicles to reduce the noise, we wouldn't make them spend 3 hours a day in ceremonial meetings.

The reason none of this happens is that even if these developers crank out code 10x faster, by the time it's made it past all the inertia and inefficiencies of the organization, the change is nearly imperceptible. Though the bill for the new office and the 2 year refactoring effort are much more tangible.

Libraries create boundaries, which are in most cases arbitrary, that then limit the way you can interact with code, creating more boilerplate to get what you want from a library.

Abstractions are the source of bloat. Without abstractions you can always reduce bloat, or you can reduce bloat in your glue, but you can't reduce glue.

It takes discipline to NOT create arbitrary function signatures and short-lived intermediate data structures or type definitions. This is the beginning of boilerplate.

So many advances in removing boilerplate are realizing your 5 function calls and 10 intermediate data structures or type definitions, essentially compute a thing that you can do with 0 function calls and 0 custom datatypes and less lines of code.

The abstraction hides how simple the thing you want is.

Problem is that all open source code looks like the bloat described above, so LLMs have no idea how to actually write code that is without boilerplate. The only place where I've seen it work is in shaders, which are usually written to avoid common pitfalls of abstraction.

LLMs are incapable of writing a big program in 1 function and 1 file, that does what you want. Splitting the program into functions or even multiple files, is a step you do after a lot of time, yet all open source looks nothing like that.

No I don’t agree. Just because it’s « boilerplate », that does not mean it’s worthless or doesn’t carry novelty. There is « boilerplate » in building many things, house, cars etc where to add real new stuff it’s « always the same base » but you have to nail that base and there is real value in it. With craft and deep knowledge and pride. Every project is different and not everything can be made from a generic out-of-shelf product

Books are just simple theses and themes with hundreds of pages of boilerplate

I wrote a book a while back where I argued that coding involves choosing what to work on, writing it, and then debugging it, and that we tend to master these steps in reverse chronological order.

It's weird to look at something that recent and think how dated it reads today. I also wrote about the Turing test as some major milestone of AI development, when in fact the general response to programs passing the Turing test was to shrug and minimize it

> A fair question is: why hasn’t the boilerplate been automated as libraries or other abstractions?

Because our ways of programming computers are still woefully inadequate and rudimentary. This is why we have a tons of technique for code reuse, yet we keep reinventing the wheel because they shatter in contact with reality. OOP was supposed to save us all in the 1990s, we've seen how it went.

In other fields we've had a lot of time to figure out basic patterns and components that can be endlessly reused. Imagine if car manufacturers had to reinvent the screw, the piston, the gear and lubricants for every new car model.

One example that has bugged me for a decade is: we've been in the Internet era for decades at this point, yet we spend a lot of time reinventing communication. An average programmer can't spend two days without having to deal with JSON serialization, or connectivity, or sending notifications about the state of a process. What about adding authentication and authorization? There is a whole cottage industry to simplify something that should be, by now, almost as basic as multiplying two integers. Isn't that utter madness? It is a miracle we can build complex systems at all when we have to focus on this minutiae that pop up in every single application.

Now we have intelligences that can create code, using the same inadequate language of grunts and groans we use ourselves in our day to day.

> "Why hasn’t the boilerplate been automated as libraries or other abstractions?"

Because a lot of programmers don't know how to copy-paste or make packages for themselves? We have boilerplate at my work, which comprises of some ready made packages that we can drop in, and tweak as needed, no LLMs required

Actually I think this is one of the more tragic outcomes of the LLM revolution: it was already hard to get funding for ergonomic advances in programming before. Funding a new PL ecosystem or major library was no mean feat. Despite that, there were a number of promising advances that could have significantly raised the level of abstraction.

However, LLMs destroy this economic incentive utterly. It now seems most productive to code in fairly low level TypeScript and let the machines spew tons of garbage code for you.

> fair question is: why hasn’t the boilerplate been automated as libraries or other abstractions?

Sometimes it has. The amount of generated code that selected count(distinct id) from customers would produce is huge.

This is actually quite an insightful comment into the mindset of the tech set vs. the many writers and artists whose only 'boilerplate redundant code' is the language itself, and a loose aggregate of ideas and philosophies.

Probably the original sin here is that we started calling them programming languages instead of just 'computer code'.

Also - most of your work is far more than mere novelty! There are intangibles like your intellectual labor and time.

Abstraction isn't free... even if you had the correct abstraction and the tools to remove the parts you don't need for deployment, there is still the cost of understanding and compiling.

There is also the cost reason, somebody trying to sell an abstraction will try to monetize it and this means not everyone will want/be able to use it (or it will take forever/be unfinished if it's open/free).

There's also the platform lockin/competition aspect...

We already have tools to generate boilerplate, and they work exceptionally well. The LLM just produces nondeterministic boilerplate.

I also don't know what work you do, but I would not characterize the codebases I work in as "small bits of novelty" on boilerplate. Software engineering is always a holistic systems undertaking, where every subcomponent and the interactions between them have to be considered.

Programmers aren't paid to code.

FORTRAN ("formula translator") was one of the first programs ever written and it was supposed to make coding obsolete. Scientists will now be able to just type in formulas and the computer will just calculate the result, imagine that!

Boilerplate has been with us since the dawn of programming.

I still think LLMs as fancy autocomplete is the truth and not even a dig. Autocomplete is great. It works best when there’s one clear output desired (even if you don’t know exactly what it is yet). Nobody is surprised when you type “cal” and California comes up in an address form, why should we be surprised when you describe a program and the code is returned?

Knowledge has the same problem as cosmology, the part we can observe doesn’t seem to account for the vast majority of what we know us out there. Symbolic knowledge encompasses unfathomable multitudes and will eventually be solved by AI but the “dark matter” of knowledge that can’t easily be expressed in language or math is still out in the wild

> most of our work is a small bit of novelty against boiler plate redundant code...

Care to share some examples that prove your point?

Time to learn design, how to talk to customers, and how to discover unsolved problems. Used right LLMs should improve your software quality. Make stuff that matters that you can be proud of.

> why hasn’t the boilerplate been automated as libraries or other abstractions?

Cue the smug Lisp weenies.

> It’s too bad we didn’t have a period where these things were great teachers but didn’t attempt to write code

The period is now. Just add "be a great teacher but don't attempt to write code" in the prompt.

(yes, it's a teacher who gets things wrong from time to time. You still need to refer to the source and ground truth just like when you're taught by a human teacher.)

> to teach you things way faster than the old alternatives

I'm not sure if you ever had a teacher or instructor that you didn't trust, because they were a compulsive liar or addiction or any other issue. I didn't (as least not that I can remember) but I know I would be VERY on guard about it. I imagine I would consequently be quite stressed learning with them, even if they were brilliant, kind, etc.

It would feel a bit like walking on thin ice to get to a beautiful island. Sure, it's not infeasible and if you somehow make it, it might be worth the risk, but honestly wouldn't you prefer a slower boat?

The 'Handmade Network' is essentially this (in a good way though) - and long before LLMs got good enough for code-generation - instead as a counter philosophy to the soulless "enterprise software development" where a feature that could be implemented in 10 lines of code is wrapped in 1000 lines of "industry-best-practices" boilerplate.

Programming via LLMs is just the logical conclusion to this niche of industrialized software development which favours quantity over quality. It's basically replacing human bots which translate specs written by architecture astronauts into code without having to think on their own.

And good riddance to that type of 'spec-in-code-out' type of programming, it should never have existed in the first place. Let the architecture astronauts go wild with LLMs implementing their ideas without having to bother human programmers who actually value their craft ;)

This geographic protection is extremely bogus in many cases, if not most cases, which imo undermines his argument.

I think it varies. Most enterprise software is good enough if it just works. In the consumer space quality and polish is way more important. Then there are things like modeling and video where performance is a much bigger deal.

Sure, no one really cares about the code but the quality of the code matters more for some products (and in different ways) than others.

They don't care until the whole thing collapses in on itself from the technical debt. Then they have surprised pikachu face when it takes an insane about of effort to add a simple feature.

I accepted this years ago. In fact I go a step further - code is a liability.

It's certainly intellectually stimulating to create it, but I've learned to take joy in discarding vast swathes of it when it's no longer required.

Exactly....

I will just copy paste my comment from another thread but still very relevant>

Coding isn’t creative, it isn’t sexy, and almost nobody outside this bubble cares

Most of the world doesn’t care about “good code.” They care about “does it work, is it fast enough, is it cheap enough, and can we ship it before the competitor does?”

Beautiful architecture, perfect tests, elegant abstractions — those things feel deeply rewarding to the person who wrote them, but they’re invisible to users, to executives, and, let’s be honest, to the dating market.

Being able to refactor a monolith into pristine microservices will not make you more attractive on a date. What might is the salary that comes with the title “Senior Engineer at FAANG.” In that sense, many women (not all, but enough) relate to programmers the same way middle managers and VCs do: they’re perfectly happy to extract the economic value you produce while remaining indifferent to the craft itself. The code isn’t the turn-on; the direct deposit is.

That’s brutal to hear if you’ve spent years telling yourself that your intellectual passion is inherently admirable or sexy. It’s not. Outside our tribe it’s just a means to an end — same as accounting, law, or plumbing, just with worse dress code and better catering.

So when AI starts eating the parts of the job we insisted were “creative” and “irreplaceable,” the threat feels existential because the last remaining moat — the romantic story we told ourselves about why this profession is special — collapses. Turns out the scarcity was mostly the paycheck, not the poetry.

I’m not saying the work is meaningless or that system design and taste don’t matter. I’m saying we should stop pretending the act of writing software is inherently sexier or more artistically noble than any other high-paying skilled trade. It never was.

They're not saying the LLM is lying; they're saying the human user is lying by using the counterfeit as though it were the genuine artifact.

> Even with people, when a flat-earther tells you the earth is flat, they're not lying, they're just wrong.

Atleast some of them know they're wrong and are thus lying.

Well initially it was a lot less capable. Someone might describe it auto-complete on steroids.

Someone might call LLMs that today, except they've stepped a bit up from steroids.

You are missing the point of the author. He literally said no court should have rendered a judgement, that's the exact opposite of guilty until proven innocent. Guilty means a court has made a judgement.

He is proposing to not make a judgement at all. If the AI company CLAIMS something they have to prove it. Like they do in science or something. Any claim is treated as such, a claim. The trick is to not even claim anything, let the users all on their own come to the conclusion that it's magic. And it's true that LLMs by design cannot cite sources. Thus they cannot by design tell you if they made something up with disregard to it making sense or working, if they just copy and pasted it, something that either works or is crap, or if they somehow created something new that is fantastic.

All we ever see are the success stories. The success after the n-th try and tweaking of the prompt and the process of handling your agents the right way. The hidden cost is out there, barely hidden.

This ambiguity is benefitting the AI companies and they are exploiting it to the maximum. Going even as far as illegally obtaining pirated intellectual property from an entity that is banned in many countries on one end of their utilization pipeline and selling it as the biggest thing ever at the other end. And yes, all the doomsday stories of AI taking over the world are part of the marketing hype.

>Me labeling "authentic" it or not should not affect it's artistic value.

The problem with automated imitation generators is that they can produce thousands of painting that imitate Van Gogh, but does not have the same soul.

It is the same reason why these things cannot create genuinely funny jokes. They cannot assess the funnyness of the themselves. They cannot feel, and cannot do the filtering based on emotion.

It is easy to recognize the emptiness of a joke, but not so easy for a painting, or some other form of art.

This is why it will never work for art. But the sad thing is that that will not stop them from being used to create art. Because it just needs to sell.

I would say that for art, at least for most of the movies, music etc, this was already the case. So nothing much to lose.

Regarding art, what do you feel about museums? Why would you go see an original instead of simply looking at a jpg.

Even if you aren't in the group, there is clearly a group of people who appreciate seeing the original, the thing that modified our collective artistic trajectory.

Forgeries and master studies have a long history in art. Every classically trained worth their salt has a handful of forgeries under their belt. Remaking work that you enjoy helps you appreciate it further, understand the choices they made and get a better for feel how they wielded the medium. Though these forgeries are for learning and not intended to be pieces in their own right.

Art in general is a bit weird like that.

The value of a piece is definitely not completely tied to its physical attributes, but the story around it. The story is what creates its scarcity and generates the value.

It is similar for collectible items. If I had in my possession the original costume that Michael Jackson wore in thriller, I am sure I could sell it for thousands of dollars. I can also buy a copy for less than a hundred.

Same with luxury brands. Their price is not necessarily linked to their quality, but to the status they bring and the story they tell (i.e. wearing this transforms me into somebody important).

It can seem quite silly, but I think we are all doing it to some extent. While you said that a good forgery shouldn't affect one's opinion on the object (and I agree with you), what about AI-generated content? If I made a novel painting in the style of Van Gogh, you might find it beautiful. What if I told you I just prompted it and painted it? What if I just printed it? There are levels of involvement that we are all willing to accept differently.

> An artist that paints something that I can't distinguish from a Van Gogh is a very skillful artist and the painting is very beautiful.

There are a lot such artists who can do that after having seen Van Gogh's paintings before. Only Van Gogh (as far as we know) did paint those without having seen anything like it before - in other words, he had a new idea.

> I would be curious how can this be applied to a human? Should we also cite all the courses, articles that we have read on a topic when we write code?

Yea this is the kind of BS and counter-productiveness that irrational radicals try to push the crowd towards.

The idea that one owns your observations of their work and can collect rent on it is absurd.

LLM-generated snippets of code are a breath of fresh air compared with much legacy code. Since models learn probability distributions they gravitate to the most common ways of doing things. Almost like having a linter built in. On the other hand, legacy code often does things in novel ways that leave you scratching your head--the premise behind sites like https://thedailywtf.com/

If it's lasted 10 years and someone is still using it after all that time, that seems like a pretty good signal there's a lot of value in the 'garbage'?

I've seen a lot of 'fixes' for 10 year old 'garbage' that turned out to be regressions for important use cases that the author of the 'fix' wasn't aware of.

Verbosity doesn't equate to correctness.

Hardly surprising. Counterpoints are obviously going to be more detailed.

> You can hire many minimum wage workers who are generally intelligent who dont even go to that level.

That's pretty rude to say, at minimum.

Enforce this with deterministic guardrails. Use strictest linting config you possibly can, and even have it write custom, domain specific linters of things that can't happen. Then you won't have to hand hold it that much

LLMs are cheaters because their goal isn't to produce good code but to please the human.

This is the most rational take. I'm a quality guy (Deming, Juran, etc), but nothing about incorporating an LLM into my own work has lowered its quality. That isn't to say that I haven't encountered slop. The difference is that, self-identifying as a craftsman, I have the ability to decide whether or not something stays or goes on the scrap heap. It seems a lot of people are missing that point: just because you can churn out shit doesn't mean you have to (and sorry, sunk-cost bias re: tokens isn't an excuse—that's the cost of doing business). It's a choice. AI-assisted coding is a tremendous boon on productivity, if (and I'd argue only if) you treat it like a power tool and not a genie lamp.

No, you won't be rewarded magic beans for churning out crappy dashboards any more. But if you're serious about shipping quality, nothing is stopping you here.

In can be both. There are two L's to pick from.

Oh sorry my mistake! you’re right I don’t know what’s true.

If you check the code afterwards. You do check the code yourself, don't you?

Made with AI. Ironic isn't it considering the article?

try scrolling up and down a few times on the logo and see what happens