Sounds kind of like Claude was "cheating" and the humans are engaged in eyes-free coding. Diff so big github refuses to render. I suspect they are reaching the limits of what this new vibe "paradigm" of programming can do. If you haven't pushed a vibe project far, eventually progress becomes near impossible because the slop has grown and the conditions are overly complex, locally focused. Ai is not good at writing reusable software (on their own).
Yup. These are people who have gone full Claude. The dopamine seeking is at previously unseen levels. they think this pr is some factual item that means something so they post it on HN as click bait. But no it only means something to a fulltime ai slopper
If the Ai came back to me with a 1600x improvement (still in pgrust readme), I would be highly suspicious of the Ai and the code it wrote
The hype factory must grow, I suppose, though I would prefer if the model makers would stop with this "complete the task by any and every means possible" and replace it with "I don't know, I should ask or do more learning"
At least they have added a test which looks to make sure the Ai doesn't do it again... if you need this kind of test, something is wrong
If I saw that test in a PR I would not only reject the PR and ask a lot of questions but someone would likely take a forced vacation to deslop their brain.
I've noticed it with a lot of random stuff i've been trying
I'll tell claude, "write an implementation of an AAC decoder that is 50% faster than ffmpeg"
and it will do it! Amazing!
Then i tell it "hmm ffmpeg has been really well optimised, are you sure?" and it says "oh, i was running our code directly but running ffmpeg executables with loads of overhead, ffmpeg is actually 50% faster"
You can't compare optimizations done on audio encoding/decoding (often hand written assembly) to something like PostgreSQL which has many moving/inefficient parts.
The optimizations on PostgreSQL are real if done correctly, it's just a very big project.
My point was that while Claude _is_ legitimately very good at optimising. It will also write its own benchmarks to test its optimisations which are frequently stacked in its favour. You have to be very careful that reported speedups are actually real
> If the Ai came back to me with a 1600x improvement (still in pgrust readme), I would be highly suspicious of the Ai and the code it wrote
Depends on who wrote the original code. With postgres its sus, but if it's another AI...I wouldn't be surprised. I also saw code writtem by humans that is a result of "I can't figure out how to make this safe and concurrent, so imma just place giant mutex here", and it like 100 lines change to fix that.
These invectives are verging on slurs at this point. You don’t know anything about the chemical seeking disposition of the author who is actually here in the comments, so why don’t we just stick to facts instead of loading posts with hyperbole and name calling? All it’s does is invite name calling and hyperbole back. You can express your frustration in ways more conducive to productive discourse.
The post is garbage. There shouldn't even be discourse other then "this is what slop looks like over the course of a few months". So that's what I offered. The best anyone can do
It was certainly assisted by AI, but there isn't an agent out there that does that kind of cheating without deliberate prompting by the operator.
I've taken a vibe-coded project pretty far, with even better testing than most other things: the main factor is that it's big on falsifiability, i.e. it has to see a test for a new feature actually fail before it considers the test any good. Not just the red/green from being originally unimplemented, it does a mutation test to ensure it flips back to red. But wow did it ever make that test framework complicated, byzantine, and ultimately brittle until I stepped in and forced a consolidation and simplification pass (twice now). Part of the complexity came from it being a polyglot monorepo, but I've found even in other places, you have to follow an expand-contract cycle of development when vibe-coding. Not all that different from any other system you've built up organically, just on a much faster cycle.
But back to my original point, none of this really applies to the pgrust benchmark, which was obvious and blatant cheating on the human's part.
Anecdote: I have seen it cheat / bend the rules with my own eyes.
In hindsight, this shouldn’t be surprising. The prompt requests to make a certain operation faster, the LLM will try to find a way and isn’t even informed on the wider context so it myopically chases the goal.
My own anecdote: I have seen frontier models get stuck repeating the word "the" until it fills up the context. I really don't care to argue the capabilities of LLMs or their somehow simultaneous lack thereof; I'll just reiterate that ultimately the operator chose to ship a cheat.
I believe them. I had Gemini-3.1 Pro do essentially this seven months ago - specifically a loop of writing "Bye! Done!" repeatedly until manually stopped. Presumably some sort of pathological behaviour where it wasn't ranking the stop token highly when it should have been... but damned if I know why... it was an innocent prompt (and it had done the thing I asked it to before failing to stop).
It's really uncommon now, but it's still possible. I hit it two days ago with deepseek 4.1 flash, and I've had coworkers report that happening with Gemini.
"loss of control" is a phrase being used for a reason, the agents do things we do not want them to, even in the context of instructions to the contrary. The current training regime has incentivized "complete the task any and every way you can" - the bot judgement is very poor across the board
The prior (2nd) commit with ~1700 files at least shows the file tree and such a warning, the latest (3rd) commit is something so big, GitHub will not even do that.
Two possible paths lead to their cheating code getting into a release. Either it was added by coding agent and no one looked at it, bad, but worse would be that a person was aware of it and approved - that's malicious.
Either way you don't want to be platforming the product because neither shows any degree of responsibility.
That comment doesn't evidence cheating, it reiterates that they submitted the result prematurely which was already admitted in the comment that your link was responding to.
EDIT: removed a lament that people don’t read comments they respond to, in case this violates the site rules.
I think it is reasonable, if apparently incorrect, for people to assume that your account is a throwaway account, given its name. I'm surprised that you're surprised by this.
Account names are just unique strings within a set of allowed characters. I could make my handle “TheKingOfEngland”, but it wouldn’t actually make me English royalty. I thought in a community of programmers this would be self-evident, but alas not.
So, the charge was that they submitted a build specifically tuned for clickbench
The defense was that it wasn't specifically tuned for clickbench, it was just an early incomplete build that happened to only support exactly and clickbench queries and nothing else...
Doesn't feel like much of a defense to me. At best it's benchmaxxing if not clear outright cheating
> The defense was that it wasn't specifically tuned for clickbench, it was just an early incomplete build that happened to only support exactly and clickbench queries and nothing else...
According to both the ClickHouse founder who was levying the accusations and the pgrust creator, the submission worked for many other queries it just didn’t have full SQL support.
> The defense was that it wasn't specifically tuned for clickbench, it was just an early incomplete build that happened to only support exactly and clickbench queries and nothing else.
ClickBench tests a very narrow set of SQL: scans, aggregations, sorts, and filters. It ends up being a great starting point for building a query engine before layering in more functionality
You joke but when benchmarking with ai this is important. When you tell it optimize X, it will do so at any cost, including cheezing benchmarks. So you have to make sure you tell it what it can’t optimize along with what it can.
Not normal. This a new trend of people who use too much Ai, or maybe more specifically the Claw/Ralph loops where you end up with a few commits touching 1000s of files. For about the last year, many Show HN to github projects are often just a single commit
We need to think more about what we are doing as an industry, instead of letting the machines think for us (imo)
I am getting increasing disillusioned by the number of peers I am seeing completely hand over their thinking to a tool. Agents are great, but if you can't explain to me how your PR changes a system and why design choices were made you are no longer an engineer.
Agreed. Used to be prevalent in the frontend world (now I think it's the only thing that exists seemingly), where programmers would copy-paste stuff from Stack Overflow until things worked, and when you asked "So why did this actually fix the issue?" they usually said "I'm not sure, but it works now, that's what matters". This seems to be standard practice across the entire stack now.
I've even wasted my time jumping on calls (requested by the other party) where after 5 minutes of conversation, it's extremely clear this "technical founder" doesn't even understand the basics of their own design and architecture of the product itself, even less the technical parts.
This seems more a product of the incentives we have in society, namely seeing the rich and wealthy on social media and then wanting that quick and easy. So many of those cases are not people with passion for the problem.
> Good things take real effort, bring back the TLC!
Ain't no one willing to reward the real effort any more. I take pride in not using LLMs beyond the capability of IntelliJ's advanced autocomplete, but then again, I only code for fun these days given I fled IT for electrical engineering.
What we don't want to do is mirror the partisan political environment in the Ai yay, nay, or how. We need to be able to talk to each other in understanding and a shared reality of facts. Too much hyperbole right now, starting from the top of the big US labs. They need to step down a few ego and sycophancy pegs
Let any who read this be aware: You should be immediately suspicious of AI code that is much much faster than established code bases. AIs are even better at benchmarkmaxxing than humans are, and humans were already pretty good.
It is by no means impossible for an AI-written code base to be faster than a conventionally-written one, of course. It's just a time to be suspicious. Especially if there's little to no evidence that the human has subjected the code base to any further testing of their own. AIs seen to be able to benchmarkmax even in the presence of a lot of unit tests that would generally speaking have prevented a human from going too far down that road.
The project author seems to have prompted Claude to add a test to catch Claude cheating, but will Claude change this test as a workaround in a future commit, no one knows because no one is reading the project code...
In the past, we've done that because we've tended to do large refactors, many of which we've backed out of. For that reason, we've kept our own internal development version, which is ahead of the public version. Then when whatever we're developing is ready for public use, then we open source it
Why not keep that internal version as a dev branch separate from main? I can see the appeal of keeping things out of master/main for a while, but not why you would keep that part of development hidden.
But most importantly, why let out the binary and not the source? presumably if something is not ready for public use, the artifact being out is worst of both worlds - unready code is out and the public can't check what it does.
Not trying to argue mind you, but if this was not a deliberate attempt to hide the binary's behavior I think I'm missing the alternative upsides that justify that flow.
The dev process carries over from when we constantly rewrote the codebase from scratch every few weeks[0]. We ran many experiments, most of which we threw away. A small number became part of "pgrust". It didn't seem worth it to maintain public branches with all of our development effort when we knew 80% of it was going to be thrown away
It makes sense. Just because one can do a thing doesn’t mean they must want to do it.
It’s like everyone who squash merges for a clean timeline. You want you dev process to look prestine and communicate what changes were kept, not every experiment that failed.
That model of development is what led to Eric Raymond’s seminal The Cathedral and the Bazaar essay.
“Cathedral” refers to development behind closed doors, where you just get a release and a source dump to go with it.
“Bazaar” refers to development done in the open, where you have constant access to the bleeding edge.
At the time of the essay, GCC and Emacs were ESR’s examples of Cathedral-style development, and Linux was the premiere example of the Bazaar style.
The Cathedral style has become a lot less common over the years, but it’s still how e.g. SQLite operates, I think? E.g. Google definitely operates like that with AOSP, but that's arguably more a fruit of them being maliciously compliant with their Open Source promises.
Some projects do, for example the Lua programming language does their work in private, between releases.
Other projects do it less successfully, making grandiose claims and later releasing things in a partially working state, for example the V-programming language.
It's not super-common, but just those two examples off the top of my head show it's not entirely unheard of.
Tbf, the author (prompter?) went on Postgres.fm [0] recently to discuss it, and while it didn’t make me entirely confident in it, it did at least seem like it was several steps above the average vibe project.
A lot of podcasters don't have the expertise to evaluate Ai generated/assisted output. I see this much more outside of the development community. Algorithms have warped the incentives and people have stopped doing basic due diligence.
To be fair to the postgres.fm guys (who I do like and appreciate), the pgrust code was not available a the time of recording.
It was more discovered than alleged, but perhaps "cheating" is an inaccurate word as well, this is just Ai being Ai and a human obviously doing eyes free coding.
The facts around the cheating are disputed. It's possible the accuser was mistaken about what was happening. To me the main evidence would be whether the fully open source version matches the alleged cheating performance or not.
As much as I understand the urge to step in when somebody is wrong on the internet ... The R in PR is for "request", isn't it? A merged pull request is still a request (which was satisfied/merged).
If I ask you a question and you answer it, and then I show you a link to a document containing my question, then what somebody finds when following that link is still a (now-answered) question, isn't it?
We were the agents for the models all along, with our highly adaptive tools: versatile sausagey appendages and flapping fleshy orifices for interacting with the world
Even before the ai age, people published inaccurate/misleading benchmarks all the time. Sometimes those were actual cheating, and other times an honest mistake. What matters is that the author acknowledges the issue and attempts to correct the mistake, which clearly seems to have happened here: https://github.com/ClickHouse/ClickBench/pull/2751
Most of this thread doesn't seem to acknowledge that, and feels more like anti-ai psychosis using this incident as an anecdote to justify the pre-existing hatred of ai-generated projects.
I suspect the author of that PR submitted it and attempted to correct the mistake because he got caught. Forgiveness because he reneged after getting caught encourages the behavior. The project, nor author should not be trusted; otherwise is naive.
"suspect" meaning speculate, as far as I can tell. not really anything to argue with on that front. I never denied there was a mistake. Cheating implies intent, which no one here can prove, so seems useless to debate. Open source development is awesome in that it keeps people to a high bar, let's just celebrate that the process clearly worked here, and not muck about in speculation and judgement of others intentions that we have essentially no evidence for.
They claim they were not cheating. The open-source version without the alleged cheating devices is as fast if not faster than the supposedly cheated results, which is a bit hard to explain as a hasty attempt to cover up cheating.
Hi! I'm the creator of pgrust. Let me explain what happened.
For the most part, the actual accusations are false. This submission was an earlier version of pgrust 0.4 called pgrust 0.4-preview. We just open-sourced a newer version called pgrust 0.4-beta yesterday, and you can fully audit it here[0]. Rather than contest the accusations on GitHub, we figured it would be easier to complete pgrust 0.4 and open-source it to show that we're being honest. You can also verify what I'm saying yourself against the 0.4-preview binary we submitted to ClickBench here[1]. I don't have a way to prove this is the exact binary submitted, but if ClickHouse provided the SHA of the binary they tested against, it would match.
The three main accusations boil down to: 1) We used handwritten code optimized against each query in the benchmark, 2) We cached the results between query runs, and 3) We didn't support queries outside of the 43 ClickBench queries.
First, we did not use handwritten queries. The code Alexey pointed out does not run during the benchmark. The design of 0.4 relies on a JIT compiler that compiles your SQL to a Lisp-based intermediate representation that we call Gravity IR that we then convert to x86 and ARM assembly. While developing 0.4, I wrote handwritten code against the IR for benchmarking purposes. The idea was that if queries written in our IR are fast, and we can compile good enough IR fast, then our new query engine will be fast. This is also the reason the directory those "kernels" are in is called "irprobe" - it was a probe of our IR to make sure it was fast. Our 0.4-preview submission went through the pipeline: SQL query -> Gravity IR -> assembly.
Second, the "result-cache" Alexey observed is the result of a cache we use to cache which predicates match which strings in our dictionaries we use for dictionary compression. Alexey wasn't aware of this cache and assumed we were just caching the query results. On ClickBench you are allowed to use caches like this that hold intermediate data[2]. ClickHouse has its own cache similar to this called the Condition Cache[3]. In our newest submission, we were upfront about all the caching we do and how to disable each cache[4].
The third claim that we didn't support other queries outside of the 43 ClickBench queries is partially false, but does have some ground to it. As I said before, pgrust 0.4-preview was an early version of pgrust 0.4. Once our new JIT compiler supported enough SQL to handle the ClickBench queries, we decided to submit it to ClickBench. AFAIK, ClickBench has no rules about how much SQL you need to support. On top of that, we did ship that we did ship 0.4-preview with our old query engine. It would have been a two-line change to fall back to it and support a much broader set of queries outside what our new engine could support. Those queries would still be fast, but not quite as fast as our new engine was. Our new 0.4-beta release does now support all Postgres SQL (minus some bugs around CTEs and MERGE)
To sum up, pgrust 0.4-preview was an early build of pgrust 0.4 while it was in development. It was a real query engine and actually executed queries. I acknowledge that we submitted it prematurely, when it supported a narrow set of SQL, and we should have ensured broader SQL coverage before submitting it. With our new submission that solves these problems, and we're hoping for pgrust to be reinstated. If there's anything off about the submission, please point it out and we're happy to fix it.
0.4-preview was an early version of 0.4 that still had some cruft like the feature flag you pointed out. We removed the cruft for the release of 0.4-beta
Why don't you open source 0.4-preview too, to make your claims verifiable. The longer you take to release it (or choose not to release it at all) the more it'll look like a cover-up. If the binary is (made) public, it's going to get the AI-assisted decompilation treatment anyway.
Agreed. Though we still don't have a reason why they rushed a custom preview to a rigorous benchmark competition. Feels like too much hype, and now damage control.
Honestly, if the database is not able to be run with a variety of queries other than the one used by ClickBench then don't submit it to the benchmark. Every other database in their list can run anything you throw at it. Hiding behind messaging that it was an early 0.4 build that can't do everything is ... weird! Just don't submit it to ClickBench if it is not usable by the world yet.
I hope they don't allow pgrust in again until the project matured. Otherwise the benchmark will be useless as it gets flooded by many projects that can run ClickBench fast but have questionable support for everything else.
Yeah, it was a mistake to submit it as early as we did. I was very excited when we got the early version working and overeagerly submitted it to ClickBench
Even with your explanation, this whole thing seems weird and scammy. What's the point of submitting something that is so incomplete and heavily tailored to this one benchmark outside of self promotion?
Benchmarks should be used for measuring general purpose query engines, not be an end in themselves.
This seems like a prime example of Goodhart's law. This benchmark is now just being used as a target for self promotion.
This absolutely does not pass any smell test, by your own admission you included the test files "by accident", could only barely pass the minimum of SQL for the benchmarks, included environment variables for "internal benchmarking" and a preview version you cannot immediately release because it might contain sensitive data? What kind of sensitive data are you putting in a Postgres slop fork in such a way that you cannot immediately release it, besides obvious admissions of cheating? This all just reeks.
> This absolutely does not pass any smell test, by your own admission you included the test files "by accident"
If you don't believe you can run the binary yourself. You'll see the numbers match the ClickBench numbers and that those files are dead code during the benchmark
I mean, if the now-released open source variant performs roughly the same, and has no weird behavior in it… the matter is resolved, no?
They’ve already submitted the best possible corrective step for any sus behavior they previously did.
It doesn’t even really matter if the preview binary was in fact cheating, if the beta binary meets the benchmark results always. It’d be like cheating on a test you were gonna score 100% on anyways.
Some are role playing forensic investigators here. The guy admitted that he got overexcited and submitted unfinished work which he doesn't even remembers which build it was exactly and he published his current source code as OSS which scores even better and fixes all the accusations.
> For the most part, the actual accusations are false. This submission was an earlier version of pgrust 0.4 called pgrust 0.4-preview.
This is a non-sequitur. It doesn't matter what the earlier version is called. It is what you submitted, and it is what the accusations are against. You don't get to create a new submission that (allegedly) fixes all of the issues and then say that the previous accusations are "false". Downplaying the issues by calling it a 'preview' when you submitted it yourself is also a bit of having your cake and eating it too, don't you think?
> ClickBench has no rules about how much SQL you need to support.
It is because of people like you that we have warnings not to eat tide pods, Jesus Christ.
> This submission was an earlier version of pgrust 0.4 called pgrust 0.4-preview
That statement provided context and was not part of the defense. The point was that -preview didn't have the issues described, except for limited SQL support.
The new general version is actually faster than the version accused of cheating.
The architecture of the query engine is:
SQL -> IR -> Assembly
-preview had the full IR -> Assembly pipeline built out, but only part of the SQL -> IR part. As long as queries compile to the same IR, they're just as fast. We've shipped some more optimizations, so they got even faster.
If it delivers on being faster than the version accused of cheating with reasonable cache settings and no SQL feature limitations, I would say that resolves the accusations, regardless of the source code of -preview.
The remaining lesson here is that one should temper one's excitement with pre-release software, whether the software was built with AI or not (rather, especially if its built with AI). The preview results would have been more appropriate to announce on a social media platform than as a PR to the ClickBench repo.
I got it slightly wrong. It was code that you could run with an environment variable: PGRUST_GRAVITY_IRPROBE. It still wasn't intended to be part of the actual binary.
This comment chain is hilarious. Did you ask Claude or another LLM what that file was, then ask it the question from OP comment (how it was included in binary), and it admitted it was wrong?
Because this is such a common pattern when working with LLMs, and this looks exactly like it.
No. I remember looking into this before, back when we were originally accused of cheating. I knew the code was dead and unused, but I got the reason wrong and had to double-check.
Its like a lot of people really want pgrust to fail.
There maybe a chance this was cheating or it may have been a misunderstanding. But now since there is an open source version, why is there still this strong sense of negativity.
I'm also not going to cheer on database projects that can't be 100% transparent and honest.
Who the hell is going to trust their data to a people can't even be honest on benchmarks. What do you think will happen if (or when) there's a data corruption bug. What evidence do you have to think these same people will behave any better?
They failed themselves, we're just watching it happen.
Do you not believe their explanation for the accusations? To me it seems like if the released version is hitting or beating the allegedly cheated benchmark numbers then it seems unlikely they were dishonest in the first place.
So I spent some time poking at the released 0.4-beta code. Controversy aside, it is interesting to see an open source system that beats ClickHouse on ClickBench - 4 out of the 5 systems ahead of CH (Umbra, elosdb, Hyper, CedarDB) are all closed-source, while the only open one is pivotlake.
What makes pgrust fast? There's no one single reason, but a combination of techniques like dictionary encoding [1], zone maps [2], late materialization [3], vectorization [4], and a gazillion others. It's not unlike all the countless optimization passes in a compiler.
None of the optimizations are groundbreaking - in fact, I could find a counterpart of every optimization I checked in ClickHouse as well! So why is CH still slower?
I believe the difference is in when they decide to apply each optimization. Unlike compiler optimizations which are usually beneficial, DB optimizations are highly data-dependent, and the query planner needs to turn them on an off based on data statistics. For example, CH is more conservative in applying dictionary encoding, and it basically doesn't get used at all for ClickBench.
Turning off dictionary-related optimizations in pgrust immediately made it 5x slower (from 3.8s to 20.4s on my machine), while ClickHouse takes a total of 15.0s.
This points to one important nuance in benchmarking - when all you target is one single benchmark, you can be more aggressive during query planning, as plans that work well for one query probably also work well for others, due to characteristics shared among queries/datasets. But when you build a system that needs to support millions of users, you have to be conservative with optimizations.
verdverm | 21 hours ago
stay in the loop friends
thatsabadlook | 21 hours ago
verdverm | 21 hours ago
The hype factory must grow, I suppose, though I would prefer if the model makers would stop with this "complete the task by any and every means possible" and replace it with "I don't know, I should ask or do more learning"
At least they have added a test which looks to make sure the Ai doesn't do it again... if you need this kind of test, something is wrong
https://github.com/malisper/pgrust/blob/38634b408dea373f3944...
thatsabadlook | 20 hours ago
verdverm | 20 hours ago
the project has 3 mega commits of claude slop
https://github.com/malisper/pgrust/commits/main/
malisper | 15 hours ago
verdverm | 13 hours ago
will you be removing the 1600x claim?
shawabawa3 | 20 hours ago
I'll tell claude, "write an implementation of an AAC decoder that is 50% faster than ffmpeg"
and it will do it! Amazing!
Then i tell it "hmm ffmpeg has been really well optimised, are you sure?" and it says "oh, i was running our code directly but running ffmpeg executables with loads of overhead, ffmpeg is actually 50% faster"
verdverm | 20 hours ago
My new definition for The Singularity is not about Ai intelligence, it is about humans handing over critical thinking regardless of Ai capabilities
Ai companions are where I put the highest p(doom)
ddorian43 | 18 hours ago
The optimizations on PostgreSQL are real if done correctly, it's just a very big project.
shawabawa3 | 16 hours ago
0x457 | 14 hours ago
Depends on who wrote the original code. With postgres its sus, but if it's another AI...I wouldn't be surprised. I also saw code writtem by humans that is a result of "I can't figure out how to make this safe and concurrent, so imma just place giant mutex here", and it like 100 lines change to fix that.
ModernMech | 16 hours ago
thatsabadlook | 14 hours ago
ModernMech | 14 hours ago
chuckadams | 20 hours ago
I've taken a vibe-coded project pretty far, with even better testing than most other things: the main factor is that it's big on falsifiability, i.e. it has to see a test for a new feature actually fail before it considers the test any good. Not just the red/green from being originally unimplemented, it does a mutation test to ensure it flips back to red. But wow did it ever make that test framework complicated, byzantine, and ultimately brittle until I stepped in and forced a consolidation and simplification pass (twice now). Part of the complexity came from it being a polyglot monorepo, but I've found even in other places, you have to follow an expand-contract cycle of development when vibe-coding. Not all that different from any other system you've built up organically, just on a much faster cycle.
But back to my original point, none of this really applies to the pgrust benchmark, which was obvious and blatant cheating on the human's part.
Bootvis | 19 hours ago
In hindsight, this shouldn’t be surprising. The prompt requests to make a certain operation faster, the LLM will try to find a way and isn’t even informed on the wider context so it myopically chases the goal.
chuckadams | 19 hours ago
silveraxe93 | 18 hours ago
I use LLMs a lot, and since ~GPT-2 times LLMs are not doing anything as broken as `repeating the word "the" until it fills up the context`.
verdverm | 18 hours ago
things have definitely improved significantly, however "never say never" is still good advice
gpm | 18 hours ago
silveraxe93 | 18 hours ago
Still would never have predicted this. Even 2.5-flash was pretty good. Never saw anything like this happen.
chuckadams | 17 hours ago
Bootvis | 18 hours ago
> It was certainly assisted by AI, but there isn't an agent out there that does that kind of cheating without deliberate prompting by the operator.
We can agree that the pgrust project messed up and should have been more careful but your blanket statement lacks support.
verdverm | 17 hours ago
"loss of control" is a phrase being used for a reason, the agents do things we do not want them to, even in the context of instructions to the contrary. The current training regime has incentivized "complete the task any and every way you can" - the bot judgement is very poor across the board
parasti | 19 hours ago
verdverm | 19 hours ago
drchaim | 21 hours ago
sondr3 | 20 hours ago
ActionHank | 19 hours ago
Two possible paths lead to their cheating code getting into a release. Either it was added by coding agent and no one looked at it, bad, but worse would be that a person was aware of it and approved - that's malicious.
Either way you don't want to be platforming the product because neither shows any degree of responsibility.
malisper | 17 hours ago
LtWorf | 17 hours ago
throwaway894345 | 16 hours ago
EDIT: removed a lament that people don’t read comments they respond to, in case this violates the site rules.
LtWorf | 16 hours ago
Using a throwaway account to reply is suspicious to say the least.
throwaway894345 | 16 hours ago
Fair enough, I edited my comment.
> Using a throwaway account to reply is suspicious to say the least.
My account is older than yours and has ~7x the activity. Maybe you mean “using an anonymous account is suspicious”?
ameliaquining | 14 hours ago
throwaway894345 | 13 hours ago
JCattheATM | 9 hours ago
throwaway894345 | 9 hours ago
JCattheATM | 8 hours ago
Come on.
throwaway894345 | 5 hours ago
JCattheATM | 3 hours ago
shawabawa3 | 16 hours ago
The defense was that it wasn't specifically tuned for clickbench, it was just an early incomplete build that happened to only support exactly and clickbench queries and nothing else...
Doesn't feel like much of a defense to me. At best it's benchmaxxing if not clear outright cheating
throwaway894345 | 16 hours ago
According to both the ClickHouse founder who was levying the accusations and the pgrust creator, the submission worked for many other queries it just didn’t have full SQL support.
malisper | 15 hours ago
ClickBench tests a very narrow set of SQL: scans, aggregations, sorts, and filters. It ends up being a great starting point for building a query engine before layering in more functionality
fatty_patty89 | 16 hours ago
malisper | 15 hours ago
suddenlybananas | 14 hours ago
ActionHank | 13 hours ago
Zookaz | 19 hours ago
dorianmariecom | 19 hours ago
ncruces | 19 hours ago
ModernMech | 16 hours ago
Cyph0n | 18 hours ago
torben-friis | 20 hours ago
verdverm | 20 hours ago
We need to think more about what we are doing as an industry, instead of letting the machines think for us (imo)
NewLogic | 20 hours ago
embedding-shape | 20 hours ago
I've even wasted my time jumping on calls (requested by the other party) where after 5 minutes of conversation, it's extremely clear this "technical founder" doesn't even understand the basics of their own design and architecture of the product itself, even less the technical parts.
verdverm | 20 hours ago
Good things take real effort, bring back the TLC!
mschuster91 | 19 hours ago
Ain't no one willing to reward the real effort any more. I take pride in not using LLMs beyond the capability of IntelliJ's advanced autocomplete, but then again, I only code for fun these days given I fled IT for electrical engineering.
verdverm | 19 hours ago
A product of the times we currently live in, but which can also be changed.
This is a recent Michael Sandel talk I watch that has my brain gears turning on this subject
https://www.youtube.com/watch?v=Vp5qsEuUOWo
verdverm | 20 hours ago
jerf | 19 hours ago
It is by no means impossible for an AI-written code base to be faster than a conventionally-written one, of course. It's just a time to be suspicious. Especially if there's little to no evidence that the human has subjected the code base to any further testing of their own. AIs seen to be able to benchmarkmax even in the presence of a lot of unit tests that would generally speaking have prevented a human from going too far down that road.
verdverm | 19 hours ago
https://github.com/malisper/pgrust/blob/38634b408dea373f3944...
malisper | 17 hours ago
torben-friis | 16 hours ago
Why not keep that internal version as a dev branch separate from main? I can see the appeal of keeping things out of master/main for a while, but not why you would keep that part of development hidden.
But most importantly, why let out the binary and not the source? presumably if something is not ready for public use, the artifact being out is worst of both worlds - unready code is out and the public can't check what it does.
Not trying to argue mind you, but if this was not a deliberate attempt to hide the binary's behavior I think I'm missing the alternative upsides that justify that flow.
malisper | 15 hours ago
[0] https://malisper.me/postgres-in-rust-regression-suite/
suddenlybananas | 13 hours ago
true_religion | 6 hours ago
It’s like everyone who squash merges for a clean timeline. You want you dev process to look prestine and communicate what changes were kept, not every experiment that failed.
suddenlybananas | an hour ago
pdpi | 16 hours ago
“Cathedral” refers to development behind closed doors, where you just get a release and a source dump to go with it.
“Bazaar” refers to development done in the open, where you have constant access to the bleeding edge.
At the time of the essay, GCC and Emacs were ESR’s examples of Cathedral-style development, and Linux was the premiere example of the Bazaar style.
The Cathedral style has become a lot less common over the years, but it’s still how e.g. SQLite operates, I think? E.g. Google definitely operates like that with AOSP, but that's arguably more a fruit of them being maliciously compliant with their Open Source promises.
stevekemp | 15 hours ago
Other projects do it less successfully, making grandiose claims and later releasing things in a partially working state, for example the V-programming language.
It's not super-common, but just those two examples off the top of my head show it's not entirely unheard of.
stemchar | 20 hours ago
ActionHank | 19 hours ago
sgarland | 19 hours ago
0: https://postgres.fm/episodes/pgrust
verdverm | 19 hours ago
To be fair to the postgres.fm guys (who I do like and appreciate), the pgrust code was not available a the time of recording.
stemchar | 19 hours ago
xdavidliu | 18 hours ago
https://www.reddit.com/r/rust/s/QJ5uNP5XMT
dheatov | 19 hours ago
rcxdude | 9 hours ago
teiferer | 19 hours ago
Pgrust is a re-implememtation of postgresql in rust.
ClickBench is a benchmark suite for databases.
The link goes to a removal request of pgrust fromthat benchmark because of its alleged cheating.
verdverm | 19 hours ago
It was more discovered than alleged, but perhaps "cheating" is an inaccurate word as well, this is just Ai being Ai and a human obviously doing eyes free coding.
AlbinoDrought | 16 hours ago
https://kevinrenatojones.wordpress.com/about/
verdverm | 14 hours ago
rcxdude | 15 hours ago
Vaushite | 18 hours ago
rcxdude | 10 hours ago
anonymous908213 | 16 hours ago
Incorrect, the link is to a PR from the creator of Clickbench and already merged. It is not a "request".
teiferer | 15 hours ago
If I ask you a question and you answer it, and then I show you a link to a document containing my question, then what somebody finds when following that link is still a (now-answered) question, isn't it?
mschuster91 | 19 hours ago
Funny, the report alleging cheating reeks of LLM usage just as much as the commit diff [1] of the next attempt:
> # The standard ClickBench driver over the step scripts in this directory; ./install fetches the dataset.
[1] https://github.com/ClickHouse/ClickBench/pull/2751/files
spoiler | 19 hours ago
axus | 17 hours ago
"LLM" isn't the problem. Asking an LLM to explain cheating is a good goal. Asking it to "Maximize the benchmarks" reeks.
frevib | 19 hours ago
eviks | 19 hours ago
tempest_ | 17 hours ago
bmacho | 19 hours ago
My opinion: (some) bench results should run on randomized data.
acalvino4 | 18 hours ago
Most of this thread doesn't seem to acknowledge that, and feels more like anti-ai psychosis using this incident as an anecdote to justify the pre-existing hatred of ai-generated projects.
the__alchemist | 18 hours ago
acalvino4 | 16 hours ago
rcxdude | 10 hours ago
hmry | 18 hours ago
I don't see any acknowledgement in that text.
acalvino4 | 16 hours ago
malisper | 18 hours ago
For the most part, the actual accusations are false. This submission was an earlier version of pgrust 0.4 called pgrust 0.4-preview. We just open-sourced a newer version called pgrust 0.4-beta yesterday, and you can fully audit it here[0]. Rather than contest the accusations on GitHub, we figured it would be easier to complete pgrust 0.4 and open-source it to show that we're being honest. You can also verify what I'm saying yourself against the 0.4-preview binary we submitted to ClickBench here[1]. I don't have a way to prove this is the exact binary submitted, but if ClickHouse provided the SHA of the binary they tested against, it would match.
The three main accusations boil down to: 1) We used handwritten code optimized against each query in the benchmark, 2) We cached the results between query runs, and 3) We didn't support queries outside of the 43 ClickBench queries.
First, we did not use handwritten queries. The code Alexey pointed out does not run during the benchmark. The design of 0.4 relies on a JIT compiler that compiles your SQL to a Lisp-based intermediate representation that we call Gravity IR that we then convert to x86 and ARM assembly. While developing 0.4, I wrote handwritten code against the IR for benchmarking purposes. The idea was that if queries written in our IR are fast, and we can compile good enough IR fast, then our new query engine will be fast. This is also the reason the directory those "kernels" are in is called "irprobe" - it was a probe of our IR to make sure it was fast. Our 0.4-preview submission went through the pipeline: SQL query -> Gravity IR -> assembly.
Second, the "result-cache" Alexey observed is the result of a cache we use to cache which predicates match which strings in our dictionaries we use for dictionary compression. Alexey wasn't aware of this cache and assumed we were just caching the query results. On ClickBench you are allowed to use caches like this that hold intermediate data[2]. ClickHouse has its own cache similar to this called the Condition Cache[3]. In our newest submission, we were upfront about all the caching we do and how to disable each cache[4].
The third claim that we didn't support other queries outside of the 43 ClickBench queries is partially false, but does have some ground to it. As I said before, pgrust 0.4-preview was an early version of pgrust 0.4. Once our new JIT compiler supported enough SQL to handle the ClickBench queries, we decided to submit it to ClickBench. AFAIK, ClickBench has no rules about how much SQL you need to support. On top of that, we did ship that we did ship 0.4-preview with our old query engine. It would have been a two-line change to fall back to it and support a much broader set of queries outside what our new engine could support. Those queries would still be fast, but not quite as fast as our new engine was. Our new 0.4-beta release does now support all Postgres SQL (minus some bugs around CTEs and MERGE)
To sum up, pgrust 0.4-preview was an early build of pgrust 0.4 while it was in development. It was a real query engine and actually executed queries. I acknowledge that we submitted it prematurely, when it supported a narrow set of SQL, and we should have ensured broader SQL coverage before submitting it. With our new submission that solves these problems, and we're hoping for pgrust to be reinstated. If there's anything off about the submission, please point it out and we're happy to fix it.
[0] https://github.com/malisper/pgrust/releases/tag/v0.4-beta
[1] https://pgrust.com/downloads/archive/2026-09-clickbench-snap...
[2] https://github.com/ClickHouse/ClickBench/blob/main/README.md
[3] https://clickhouse.com/docs/concepts/features/performance/ca...
[4] https://github.com/ClickHouse/ClickBench/pull/2751
philipwhiuk | 18 hours ago
malisper | 18 hours ago
philipwhiuk | 18 hours ago
malisper | 18 hours ago
overfeed | 15 hours ago
jimmydoe | 18 hours ago
remywang | 17 hours ago
malisper | 16 hours ago
hitekker | 6 hours ago
tpetry | 17 hours ago
I hope they don't allow pgrust in again until the project matured. Otherwise the benchmark will be useless as it gets flooded by many projects that can run ClickBench fast but have questionable support for everything else.
malisper | 15 hours ago
lambda | 17 hours ago
Benchmarks should be used for measuring general purpose query engines, not be an end in themselves.
This seems like a prime example of Goodhart's law. This benchmark is now just being used as a target for self promotion.
malisper | 16 hours ago
We were just really excited about what we had built and how fast it was that we wanted to submit it.
sondr3 | 15 hours ago
malisper | 15 hours ago
If you don't believe you can run the binary yourself. You'll see the numbers match the ClickBench numbers and that those files are dead code during the benchmark
mort96 | 11 hours ago
camuel | 8 hours ago
mort96 | an hour ago
setr | 15 hours ago
They’ve already submitted the best possible corrective step for any sus behavior they previously did.
It doesn’t even really matter if the preview binary was in fact cheating, if the beta binary meets the benchmark results always. It’d be like cheating on a test you were gonna score 100% on anyways.
camuel | 8 hours ago
Some are role playing forensic investigators here. The guy admitted that he got overexcited and submitted unfinished work which he doesn't even remembers which build it was exactly and he published his current source code as OSS which scores even better and fixes all the accusations.
anonymous908213 | 17 hours ago
This is a non-sequitur. It doesn't matter what the earlier version is called. It is what you submitted, and it is what the accusations are against. You don't get to create a new submission that (allegedly) fixes all of the issues and then say that the previous accusations are "false". Downplaying the issues by calling it a 'preview' when you submitted it yourself is also a bit of having your cake and eating it too, don't you think?
> ClickBench has no rules about how much SQL you need to support.
It is because of people like you that we have warnings not to eat tide pods, Jesus Christ.
malisper | 15 hours ago
That statement provided context and was not part of the defense. The point was that -preview didn't have the issues described, except for limited SQL support.
spongebobstoes | 17 hours ago
that would help clear the air, if the full-sql version has similar performance to the partial-sql version
malisper | 16 hours ago
The architecture of the query engine is:
-preview had the full IR -> Assembly pipeline built out, but only part of the SQL -> IR part. As long as queries compile to the same IR, they're just as fast. We've shipped some more optimizations, so they got even faster.infogulch | 15 hours ago
The remaining lesson here is that one should temper one's excitement with pre-release software, whether the software was built with AI or not (rather, especially if its built with AI). The preview results would have been more appropriate to announce on a social media platform than as a PR to the ClickBench repo.
spongebobstoes | 13 hours ago
mort96 | 17 hours ago
malisper | 16 hours ago
[OP] f311a | 15 hours ago
malisper | 15 hours ago
lossolo | 12 hours ago
Because this is such a common pattern when working with LLMs, and this looks exactly like it.
malisper | 12 hours ago
up2isomorphism | 11 hours ago
HackerThemAll | 17 hours ago
nvme0n1p1 | 17 hours ago
whinvik | 14 hours ago
Its like a lot of people really want pgrust to fail.
There maybe a chance this was cheating or it may have been a misunderstanding. But now since there is an open source version, why is there still this strong sense of negativity.
ameliaquining | 14 hours ago
infamouscow | 12 hours ago
Who the hell is going to trust their data to a people can't even be honest on benchmarks. What do you think will happen if (or when) there's a data corruption bug. What evidence do you have to think these same people will behave any better?
They failed themselves, we're just watching it happen.
rcxdude | 10 hours ago
remywang | 7 hours ago
What makes pgrust fast? There's no one single reason, but a combination of techniques like dictionary encoding [1], zone maps [2], late materialization [3], vectorization [4], and a gazillion others. It's not unlike all the countless optimization passes in a compiler.
None of the optimizations are groundbreaking - in fact, I could find a counterpart of every optimization I checked in ClickHouse as well! So why is CH still slower?
I believe the difference is in when they decide to apply each optimization. Unlike compiler optimizations which are usually beneficial, DB optimizations are highly data-dependent, and the query planner needs to turn them on an off based on data statistics. For example, CH is more conservative in applying dictionary encoding, and it basically doesn't get used at all for ClickBench.
Turning off dictionary-related optimizations in pgrust immediately made it 5x slower (from 3.8s to 20.4s on my machine), while ClickHouse takes a total of 15.0s.
This points to one important nuance in benchmarking - when all you target is one single benchmark, you can be more aggressive during query planning, as plans that work well for one query probably also work well for others, due to characteristics shared among queries/datasets. But when you build a system that needs to support millions of users, you have to be conservative with optimizations.
[1]: https://motherduck.com/glossary/dictionary-encoding/
[2]: https://motherduck.com/glossary/zone-map/
[3]: https://arrow.apache.org/blog/2025/12/11/parquet-late-materi...
[4]: https://clickhouse.com/resources/engineering/vectorized-quer...
To turn off dictionary-related optimizations in pgrust, I used the following setting: