minimaxir

I initially had a Rust-based word cloud generator that generates word clouds in high resolution in ~100 milliseconds whereas it would take other generators a couple seconds to do the same thing. Does the world need a super-fast word cloud generator? No. Do I want a super-fast word cloud generator? Yes.

I later found enough optimizations to reduce the generation speed all the way down to ~16ms. Do I need a word cloud generator that fast? No. But if I have a word cloud generator it's going to be as fast as possible dammit.

Both the example libraries compared (tokenizers and tiktoken) are Rust-based with Python bindings. There's just a few levers in Rust that can speed it up even more particularly with LLM assistance as the AI Use Discloure here notes:

Final profiling stages and the last ~4x worth of performance from eliminating branching and improving the pretoken cache hierarchy

just repeatedly saying "keep going" to ChatGPT

For posterity, this indeed works for most problems where an agent might give up. LLMs don't inherently know something is impossible.

The phrase I tend to use in my harder prompts to automate this with a sane loop breaker:

**REPEAT THIS PROCESS UNTIL CONVERGENCE AND YOU ARE OUT OF OPTIMIZATION IDEAS.** You have permission to keep iterating.

I'll have a blog post up tomorrow about it but the Jacobian Conjecture counterexample is a very funny cognitohazard for LLM assistants. It's a paradox for modern LLMs: they have enough math skills such that they can easily compute the Jacobian to formally verify the counterargument, but its own knowledge base is locked prior July 19th 2026 where all it knows is that the Jacobian Conjecture is unsolved and a random chat user providing such a proof is highly unlikely.

It's a meme. Telling it to "make no mistakes" doesn't do anything because LLMs don't have an inherent concept of a mistake and they are already RLHFed to code correctly.

However, if you tell it to not do particular behaviors explicitly—some of which would be considered mistakes—it will not do said behaviors and with enough checks and balances, you'll get output without "mistakes".

One example of this from the OpenAI Unit Distance prompt: https://cdn.openai.com/pdf/04d1d1e4-bc75-476a-97cf-49055cd98...

Do not return merely because current approaches fail or agents report theorem-strength gaps. Continue launching new rounds, reopening blocked approaches only when there is a genuinely new mechanism, and searching for fresh formulations. Return only when a complete affirmative proof has been found and survives adversarial audit.

Do not return a reduction, partial result, isolated missing lemma, “best effort” summary, or explanation of why the problem is difficult.

Also note the timestamp: he started working on this thread a few hours after the tweet.

This proof was posted by an individual researcher, Anthropic has not used it in any of their marketing.

Additionally, posting this during the World Cup would be the most inefficient way to do marketing.

There will be more and more mathematical proofs provided by LLMs as they improve. If you assume every one is just a marketing tactic, you'll drive yourself insane.

I think the argument is sound

They got flagged because it is a literal conspiracy theory that assumes bad faith.

So the conjecture that survived Keller, Abhyankar, Moh's degree-100 verification, and five-plus published wrong proofs appears to have died via tweet during the World Cup final.

Who knew DOES NOT COMPUTE would be an actual thing?

You accused me of "lies I'm telling myself" about the robustness of current LLMs and I take offense to that when I have hard evidence that it's not a lie I'm being manipulated by. That's not deflection and I'm not sure what else you think I should be responding to.

Ironically my time and focus on agentic prompting and coding has helped me break an actual bad addiction (World of Warcraft)

Yesterday (unrelated to quotamaxxing described in the article), I made an Apple TV macOS menu bar remote app: https://cdn.bsky.app/img/feed_fullsize/plain/did:plc:oxaerni...

Every single prompt worked without issue, and it got most of the way on the first try with the initial prompt (+ a couple visibility bugs due to the agent not having Computer Vision to see said menu bar app) such as:

Create a SwiftUI menu bar app named `swiftmote` using theto create the most user friendly app following Apple's HID guidelines for creating a remote that can operate a Apple TV on a local network. Instead of reimplementing the protocols needs to interface with an Apple TV, use the Python package `pyatv` and host it within the SwiftUI app as a sidecar along with a Python installation.

I have my own Apple TV I can manually verify that it worked as expected, which is notable because the agent can't test or lie about this pipeline because it does not have access to the Apple TV.

That is not hallucination or psychosis. If you want, I can release all the prompts I used. (EDIT: Sure, why not, here are the prompts. If I don't complain about something in a followup prompt, assume it worked correctly: https://gist.github.com/minimaxir/30fa820daa1392da13026ec6aa... )

For the problems I work on with GPT 5.6 Sol and the checks and balances I have in place, I estimate:

- 80% of prompts get everything correct and are confirmed correct with manual validation

- 19% of prompts make a minor mistake based on an ambiguity of the original prompt (user error not LLM error), but then reliably fixed in a followup prompt

- 1% of prompts causes more problems than it solves and is more pragmatic to just revert

For 99% good output, there isn't much of a dopamine rush when there is good output. The dopamine rushes are for the <1% odds.

From the other replies on this post, I suspect no one believes me, but I am offering these numbers in good faith.

Said tricks improve the output in an objective measurable manner, not theoretical, vibes, or gambler's fallacy. (blog post forthcoming on that)

I've been researching LLM prompt optimization for longer than ChatGPT has existed; I was successfully optimizing the output of GPT-2 back in 2019.

I really wish there was a canonical platform endpoint to programmatically check Codex usage amount and the quota reset times so I could just vibecode an app to alert "hey, your usage just went to 100% so that means OpenAI did a reset" and "hey, your 5-hour usage is at 10%, wrap up what you're doing".

The only way to do it now is through shenanigans with the Codex App Server which is not ideal.

Over the last 2 weeks, 6 of the resets are direct to the usage limit.

In the same timeframe, 2 additional resets were banked.

Gambling addition implies dopamine hits from irregular and uncertain outcomes: as I note in the post, I don't get a dopamine hit from running agents. I know people say "LLMs are just gambling because they're next-token-maximizers that can't write real code" but with GPT 5.6 Sol (and a few new tricks I discovered) the outputs are much less irregular and uncertain. It's just typical engineering.

"Not wanting to waste money" is the polar opposite of gambling.

Note that Max is the $100/$200 per month plan; In addition to the obvious incentive to upsell, I suspect attempting to use Fable on the $20 per month plan would wreck your quota.

On a related note, Codex just reset their weekly quota, again.

It's a common discussion trope to imply malfeasance in response to good news, which is a way to non-constructively shut down a conversation particularly without elaboration. In this particular case I legit didn't understand what the OP was actually implying because they did not elaborate.

And? Is that a scandal?

If you want to use local models, it's more ergonomic than fussing with GGUFs or using LM Studio as a server host and setting up the link to an agent yourself. Although, the model selector is the same as with LM Studio itself which can be overwhelming if you don't know what to look for.

Hacker News and a RSS subscription for Techmeme is sufficient.

X/Twitter is too irony/vaguepost filled that relying on it for high-signal news actually makes you less informed.

You can do that now with a Stream Deck + XL. https://www.elgato.com/us/en/p/stream-deck-plus-xl

Those memory bugs tend to be known unknowns. It's the unknown unknowns that are really scary.

To paraphrase another comment (https://news.ycombinator.com/item?id=48900086), this project is fun and fun should be encouraged, as experimentation is what leads to more innovative things. The existence of this project doesn't take away from anything.

Memory bugs are unknown unknowns that AI may or may not catch. There's net-present-value in switching to a language where certain types of memory bugs are impossible.

Of all the tools in software engineering to be overpopular and overused, Rust is an instance where that is a very good thing.

Atleast people aren't AI rewriting things into PHP.

they legitimately thought it was slop

The issue is that label has expanded to anything that's weird/unusual, and the consequences of being accused of AI are far more severe than the consequences of a false accusation so people do it frequently. It is absolutely a vector for harrassment/trolling.

One subreddit I follow now bans people if they make an accusation of AI-generation that's weak/disproven, which is a rule I like.