gwern

(And in a pyramid of queues like many layers of reviews, each layer will wind up being about equally loaded, because otherwise you would get a big benefit from adding/removing capacity, so each layer will slowly be optimized towards its breaking point, yielding the 10x everywhere.)

Pebble went out of business, incidentally.

Remember that _American Psycho_ is repeatedly hinting to you throughout the movie that most, or even all, of what you see is just Bateman's own delusions and hallucinations, which are inferior imitations of reality due to his own impoverished mind and lack of substance. So there's a lot of little tricks all throughout it to subtly destabilize you: https://www.moviemaker.com/american-psycho-anniversary-oral-...

Thanks for writing it up!

It was probably unintentional, yeah, I don't recall any mentions of early printf being overloaded to do stuff, nor is it clear why you would do that since you're using it in a much more convenient Turing-complete language already (C).

For example, the Anthropic Rust C compiler could hardly have copied GCC or any of the many C compilers it surely trained on, because then it wouldn't have spat out reasonably idiomatic and natural looking Rust in a differently organized codebase.

Good news for Rust and Lean, I guess, as it seems like everyone these days is looking for an excuse to rewrite everything into those for either speed or safety or both.

If I, gwern, specifically, were to apply, I might; because I know I am widely read on HN and I've talked with any number of YC partners etc, and they all know I take care in writing, and so me not capitalizing is a deliberate message rather than laziness or incompetence. They may or may not appreciate the message, but they won't infer the usual things, at least.

If I were anyone else and my application just one of thousands in the flood? You'd better believe I'd capitalize and spellcheck my YC application: https://gwern.net/blog/2023/good-writing

People use Base64 to store payloads of many arbitrary things, including web pages or screenshots, both deliberately and erroneously, and so they have almost certainly seen regular conversations in Base64 in their 10tb+ text training sets scraped from billions of web pages and files and mangled emails etc.

This is an example of an article which 'buries the lede'†.

It should have started with the announcement of the new zlib autoformalization (!) https://leodemoura.github.io/blog/2026/02/28/when-ai-writes-... to get you excited.

Then it should have talked about the rest - instead of starting with rather graceless and ugly LLM-written generic prose about AI topics that to many readers is already tiresomely familiar and doubtless was tldr for even the readers who aren't repelled automatically by that.

† or in my terms, fails to 'make you care': https://gwern.net/blog/2026/make-me-care

Maybe you're looking for 'moral hazard'?

So the requirement should be that there is a prompt, or set of prompts, plus documentation, which distill out everything learned or done in a single master prompt which then suffices to build a similarly capable codebase. ('Reproducibility' in the sense of replication, getting roughly the same result, not 'reproducibility' in the sense of bit-identical builds. (This is just 'compaction' on steroids, and something I generally do not have problem doing with my own LLM creative writing, no matter how many iterations or conversations it took to get to the final idea.)

If it s not possible to create such a thing for a codebase, even with the vibecoded artifact at hand, then that raises an awful lot of questions about the quality or what went wrong, and the requirement is doing its job of keeping a Superfund site away from the rest of us.

The v0 is just this requirement. If you find that people are lying about it (which they probably will for the same reasons that they lie about Show HNs not being vibecoded or front page slop not being slop eg. https://news.ycombinator.com/item?id=47205208 ), then you can start enforcing it simply by requiring someone else to have run the prompts and found the final result to be reasonably useful and as advertised.

(This is also why people like cramming or lectures rather than quizzing or spaced repetition, because they produce a certain 'illusion of depth' https://gwern.net/doc/psychology/cognitive-bias/illusion-of-... ).

> Andrej Karpathy wrote a 200-line Python script that trains and runs a GPT from scratch, with no libraries or dependencies, just pure Python.

Almost immediately afterwards, you have a section titled "Numbers, not letters". Need I go on?

Interestingly, despite all the AI tics, the opening passes Pangram as 100% human... though all the following sections I randomly checked also come back as 100% AI. So the simplest explanation would be that you are operating adversarially and you tweaked the opening to target Pangram (perhaps through a anti-AI-detection service, which now exist and are being used by the cutting edge, as Pangram is known to be relatively easy to beat, similar to how people started search-and-replacing em-dashes when that got a little too well known), which unfortunately means I now expect you to lie to me in your response since you apparently went that far to start building up clout.

(BTW, how did you accidentally pick 4 rare names which were in the dataset? "Thanks, will fix" is not a real response to that observation. Are you also going to remove all of the 'just pure X' and 'Y, not X' constructions from your posts now that I've pointed it out?)

My suggestion would be more radical: if it's AI written, the code is increasingly irrelevant. What is relevant is the prompt or spec: https://news.ycombinator.com/item?id=47198562 'Show HN' should ban "code-only" submissions if not majority human-written, and allow only "prompt/doc/test only" 'Show HNs'.

I am interested in a vibecoded project which was a well thought out goal or an interesting methodology or a striking prompt engineering trick (eg. the Anthropic Rust C compiler targeting the Linux kernel); I'm not interested in a obvious idea where I'm supposed to be impressed by a huge pile of rotting-code-debt of unknown quality and likely a lot of bugs, which is going to be written by a LLM in a few months anyway.

> "Show me your flowchart and conceal your tables, and I shall continue to be mystified. Show me your tables, and I won't usually need your flowchart; it'll be obvious." ---Fred Brooks, _The Mythical Man Month_ (1975)

But the opening at least makes a good point: AI-written code is right now something of an embezzlement or theft or fraud. Like junk food, it presents all the appearance of coming with correlates like "an engineer now understands the problem-space and has built tacit knowledge and a theory of how the domain/code work"... But it doesn't. The human engineer takes all the credit (and promotions), having put in a tenth or less the usual work, but evades the blame or tech debt.

This is why vibecoding is the inevitable endpoint. The current code market is a lemon market, and we see the exact same kind of dynamics of 'buyers' withdrawing from 'purchases' as they see all these shiny code bases which are secretly lemons, and sellers increasingly get frustrated they can't get a 'fair price' (like anyone to look at their 'Show HN' posts).

We must understand that the source code is no more valuable than a compiled binary, and that the responsible human doesn't understand it and has to trust it, in the same way that we now understand source code but don't understand and have to trust the compiled binary. Today, I understand my Haskell code, but I have no idea what is going on in the compiled binary (nor do I claim to); tomorrow, I will understand my prompt/spec, but I will have no idea what is going on in the 'source code' (nor will anyone expect me to or admire me for 'writing all that code' or be surprised if some seriously mistaken assumption is hardwired into the generated code). Just as no one cares about a binary you compiled today, no one will care about your source code. (Unless there is something special about it, of course. 'I compiled Firefox for my Linux' - OK, congrats? 'I compiled Firefox for my toaster' - OK now I'm interested.)

So, no one will care about the codebase for your 'Show HN' project; you have to instead get them to care about your proposal or your testsuite. If it's any good, they can simply pass it to their own LLMs to 'compile'; no need to trust your crummy dubious already-obsolete 'source code'...

> On reflection I have started to worry again. In 10 to 20 years nobody will read anything any more, they just will read LLM digests. So, the single most important task of a writer starting right now is to get your efforts wired in to the LLMs. Nothing you write will matter if it is not quickly adopted to the training dataset. As the art of pushing your results to the top of the google search was the 1990s game, getting your ideas into the LLMs is today’s. Refine is no different. It’s so good, everyone will use it. So whether refine and its cousins take a FTPL or new Keynesian view in evaluating papers is now all determining for where the consensus of the profession goes.

For more recent comments, see https://dwarkesh.com/p/gwern-branwen https://gwern.net/llm-writing https://www.lesswrong.com/posts/34J5qzxjyWr3Tu47L/is-buildin... https://gwern.net/blog/2025/ai-cannibalism https://gwern.net/blog/2025/good-ai-samples https://gwern.net/style-guide

The scaling will continue until morale improves. I advise people to skate to where the puck will be, and to ask themselves: "if I knew for a fact that LLMs could do something I am doing in 1-2 years, would I still want to do it? If not, what should I be doing now instead?"