Two years ago? I don’t get it, coding agents have been compelling for barely a year.

Cursor and aider were definitely compelling two years ago. Nothing compared to now, of course, but still better than raw dogging it.

I would say from march this year.

I trailed off a few lines into the README. No human ever edited any of this. « LLM detected, project rejected ».

Every third post in HN has this same complaint comment. Everybody knows.

It's better that everyone is loud about it then everyone giving up and being silently irritated. At least if people complain it's possible to read the room

Just flag the post so it drops off the home page and loses audience.

Especially when the article _is plainly about the use of LLMs to do LLM things_.

If this was talking about buying the best apples are the supermarket, sure, complain away about the use of an LLM to talk about apples.

But it's really a specious argument about something that likely only exists because an LLM is good at creating that type of project.

That risks not communicating the reason for the downvotes / flags to the submitter. I think the value of complaining loudly is signalling to those who think LLM write-ups are acceptable (some folks are acting in good faith without understanding why the content is unwanted).

Tbh, I still wonder why people even bother releasing such tools that were shitted out by an LLM in an hour or two, these are basically the modern equivalent of a hastily cobbled together 10-liner shell script (still useful, but not something you'd ever put up as its own Github project).

Everybody else can write such tools now by themselves in at most an hour, and they get a tool that's more personalized to their tastes. And why have a readme at all when it's just LLM mumbo-jumbo - that sort of mumbo-jumbo is written for LLMs to consume, not humans.

In theory, there is some value in deciding what the LLM ought to shit out, and checking that it works, and maybe even making a design decision or two to try and create something that would be relevant or useful for many people. And then others can possibly save an hour or two, and the data centre can save some water and electricity.

In practice, well.

That sort of careful work would take more than 7 commits and 1 hour though ;)

That's 6 more commits than I'm used to seeing for these sorts of efforts, honestly. (But I will cede that people might be doing all the changes locally and then pushing a single commit, without any real understanding of how version control works.)

If folks do this; I'd love for them to also be in the habit of shipping their prompts + harness configuration too. If we are moving to another code abstraction, then that becomes the source code to modify, adapt and extend.

I mean -- compilers used to annoy developers who knew how to hand-roll machine code, with bad outputs and inefficient algorithms, till the compilers got better than most of them...

I don't quite agree with the Assembly => Compilers => LLMs as some sort of "stages of evolution" argument tbh.

LLMs are an additional way to generate code, but it's not like code generation or "low-code" tools are a new thing that made compilers and programming languages obsolete.

LLMs "just" allow to provide the code generation input directly in human language. But whether providing such a specification in "sloppy" human language instead of a precise specification language is actually a good thing for long term projects is still arguable (as convenient as it is).

Mathematicians and engineers invented their own precise "DSLs" (e.g. math notation and blueprints) for exactly this reason, and high-level programming languages are nothing else than "specification languages" that don't leave room for the ambiguities of "natural languages", and it's still not clear to me how having both a natural language specification and a precise specification in form of source code side by side can be considered a good thing. It's easy to say of course that the "natural language specification" is the single source of truth and the source code is a throwaway output artifact, but then you're back at having a specification written in a language that's useless for expressing precise intent.

(and this is also the fundamental difference between compilers and LLMs and why I believe that comparing LLMs to compilers is wrong: determinism. The output artifacts of a compiler are literally throw away. Nobody in their right mind would commit object files into version control, while nobody in their right mind would not commit the source files generated by LLMs into version control, because creating the source files from scratch would yield different results on each run).

Releasing the harness as part of LLM-generated projects still makes sense of course :)

I prefer when I see other comments to confirm or infirm my opinion.

I appreciate it when people say something is slop. Saves me from wasting my time looking at it.

How many slop ideas have come to the front page, never to be heard from again because the execution isn’t actually any good? I’m guessing most of them.

Hmm, I wonder if we can automate that

Just because the ReadMe is slop, doesn’t mean the code is slop. People are starting to make apps for themselves now and open-sourcing them so they’re not putting much thought into the ReadMe or distribution.

This just means ReadMe’s are less important now. I just have my terminal agent dig into the code and tell me what features are there. If the app is actually useful.

Even before AI, there were so many projects with subpar ReadMes, no screenshots, etc. But once you use the software, you realize how good it is.

Source: I maintain a massive collection of open-source alternatives and quality of open-source alternatives have increased a lot

If you do not respect your project to write your readme yourself chances are i will not care though.

For many new coders, LLMs are so good at writing the code, asking it to write the ReadMe sounds like a good idea. Clearly it’s the first impression your project makes so handwriting it is important.

Being turned off by the project because of the ReadMe is your prerogative. I’m just suggesting you dig into the code sometimes, the ReadMe is not the be all, end all.

> For many new coders, LLMs are so good at writing the code, asking it to write the ReadMe sounds like a good idea. Clearly it’s the first impression your project makes so handwriting it is important.

The point is that if they looked at the result they'd question themselves. And the fact that they don't is a violation of the social contract: I can hardly be expected to care about your work, if you don't.

But it takes so little effort to wade through an LLM readme and cut out or edit it down to something palatable.

Just the bare minimum effort to do that would be nice.

I apply the same rule to the code, unless it is on the job and I have to follow along with the herd, or else....

Your comment might be sarcastic, but AGENTS.md already exists for the explicit purpose of agents reading and using it.

yeah, my point is just that we agents can have their own docs and we can also have a nice curated experience for humans.

You’re right that a poor quality readme doesn’t mean a poor-quality product, but it seems more likely than not to me.

Slop is an instant tab close for me. If something’s good, it’ll come around again. I’ll catch it when there's some evidence that it’s worth my time.

You can produce good code and good projects with Claude doing all the work. This might even be an example of one, but the description on GitHub makes so little sense that I stopped reading before I figured out what it even does.

If the author is too lazy to even write their own commits, I doubt there would be any effort put into the codebase.

>Everybody knows.

Awesome!

I think these repo owners should be required to film themselves reading out their Claudemade readmes with a straight face.

Every honest caveat. Every seam. Every "Frames lie, so the walk prunes hard".

Clearly the people writing these annoying articles don't know.

I wish they'd just use Astra instead. It doesn't write this awful prose.

And every comment on HN calling out vibe-coded slop has this same complaint comment in turn. OP has an actual complaint, your complaint is just "stop complaining".

It’s not stop complaining as much as it is please contribute something of substance instead of venting hot air into a comment thread where everyone is already aware.

1/3 of articles warrantying such a comment means it is still important information. If it was 100% of the articles I would agree that it gives no information, but with 1/3 one cannot claim it does not contribute information.

Fair enough.

I'd rather read it's slop, it actually adds something to the conversation.

I'd say "imagine if half the posts on HN aren't worth your time" but this is genuinely how it feels nowadays. I'm not sorry

The problem is that not everyone thinks like you. You're dictating what is and isn't a signal to others. OP left a comment to signal to people like me. It saved me a click.

The title was perplexing enough for me.

I stopped reading at “The honest caveat”…

An llm response here would be more respectful than a downvote without a comment.

And it’s quite disrespectful to dismiss a project that may have taken a lot of time and thought, even with agents, to build, and just dismiss it because the readme was created by an agent.

> Good models these days spit out architecture and code fairly indistinguishable from your average developer.

Emphatically, no. It’s way too complex, every time. Ceinture et bretelles, as we say in French.

> Ceinture et bretelles

I do not know much French but that seems to translate literally into the common English phrase "belt and braces"

Did not know belt and braces was a saying in English! I learned something today.

Everything I've vibe coded is utlitarian, sparse, barebones, and the code itself is fewer bytes than the documentation.

You can do this if you hold its hand a lot. Claude by default will do insane levels of abstraction for small things. Also make Python docstrings 3x longer than the actual code.

Anthropic bills by the token. Incentives might be different for open weight models.

and if you hand hold its not vibe coding.

If only!

My favorite thing is leaving the skin and slicing them. Each slice has the perfect amount of skin and pulp, it’s crunchy, it’s heaven!

Did the author really put significant effort here? The LLM speak suggests the opposite.

> These are not market personas. They are architecture tests.

Indeed.

This is obviously written by an LLM. Should we flag such content?

Did I even tried to pretend the article wasn't generated with Claude's help?

I even shared the initial prompt in some comment in this thread. I don't understand what is the matter with also using AI help with generating articles. I still reviewed the article and put all the ideas I wanted to discuss in that article. I don't see why people are often complaining about this. The article content is much more important than how it was generated.

I hear your frustration and it, er, prompted me to write some thoughts about the situation.

The community is trending strongly against wanting to read generated writing. It's unclear how it will shake out in the long run, but for the near term, this preference is clear*. We can debate the reasons or what the correct position is, but it doesn't much matter when there's such a strong community verdict.

We don't have a rule against genai in articles the way we do about text appearing on HN itself (https://news.ycombinator.com/newsguidelines.html#generated) but the pushback is strong enough that it's in authors' interest to write their articles themselves. Even seemingly less invasive tools like grammar checkers and translators leave strong LLM imprints on text these days.

There is an emerging class distinction in the culture: generated writing, or writing that sounds like it, gets stigmatized and relegated to a lower-status bucket in readers' minds. The converse is also true: writing that isn't generated, and doesn't sound like it, gets boosted into a high-status bucket. It's easy enough to turn this to one's advantage: simply write your own writing.

There are even signs that mistakes (e.g. in grammar or spelling) which would formerly have counted against an author and lowered their status, are turning into markers of authenticity. This is something we point out to non-native English speakers who post to HN: don't worry about your English, just write in your own voice, because that is the high-order bit now. (https://hn.algolia.com/?dateRange=all&page=0&prefix=false&qu...)

I think your prompt was great, btw (https://news.ycombinator.com/item?id=49544844) and something most readers, including myself, would prefer to the generated output. Kudos for sharing it! We often hear readers saying they'd "rather see the prompt", but yours may be the first case I've seen of an author actually posting it.

* We've been keeping an ad hoc list of these reactions to illustrate the point: https://news.ycombinator.com/genai-pushback

Same here, what if the internals get the same absence of care? No thank you.

For a lot of people writing prose is a chore

Just hook vanilla pi to Sol and you’ll have the pair programmer agent you crave. Make sure never to install a subagent extension. That’s it!

It’s even worse, the opposite is actually true (but it’s a slight effect).

How is having numerous kids correlated with being a good parent? If anything, the reverse is probably true.

There’s “how to be a good parent” advice and there’s also “oh boy how do we manage mealtimes and laundry and the school run” type advice. Someone with lots of kids is going to have great insights into the latter at very least.

If he’s the father, he may have no involvement in the logistics whatsoever. Especially if he has a large family.

I am the father, and I have a ton of involvement in the day-to-day work of running the house. This brings me and my wife a lot of satisfaction and it undoubtedly wouldn’t be possible if I was still commuting to work in Silicon Valley.