rfgplk

Astra is still the uncontested #1 code generator.

> Paying $200 a month and part of their Cyber Verification Program but can't use Opus 5.5 or Sonnet 5.5 for any authorized bounty work. Immediately get flagged for `Cyber`.

AI providers still haven't realized how much cash they could rake in if they provided fully unrestricted models.

Seriously? I have no idea where this cognitive dissonance comes from. Or are people just lying (outwards or to themselves)? A rewrite of this magnitude would easily take a skilled human team months if not years to finish. This is on top of Rust not being an easy language to work with. Which, btw, is the sole reason why not everything is written in C/C++/Rust.

> Instead, I think what's closer to solved and what we're in the process of solving is product development.

Isn't it the opposite? How to build something is rather solved, but what to build isn't?

Frankly, I don't really see how it isn't solved, even with the current state of LLMs. Frontier models can write, understand, correct, and optimize code in practically any language at a superhuman level. I haven't come across a single problem that LLMs can't solve. You can easily give them a research paper, ask them to implement it and in an hour or two it's done. Or even point them to a video or screenshot of something and say "implement this feature in our game engine" and... they just do it. It might not be optimally perfect, but what % of human written code is? Even if you ignore the time amortization (given how models can spit out weeks of human work in an hour) they still obliterate even an experienced developer.

5,000 is the output velocity of someone not fully immersed in agentic coding. I've seen repos do ~100k to ~250k loc changes per week.

"optimize this code", "fix this code", "extend this code", "add this feature", "find errors and patch them", "find bugs and fix them", "rewrite this from python to rust".

This is all that's needed to actually use LLMs nowadays. How is it a "multiplier" rather than an "equalizer"?

Google's products are littered with CVEs. Disappointing for a supposed "frontier" lab. Can't they hire competent people?

Not only would I buy it, I'd win it too. Statute of limitations is irrelevant here. Property rights are eternal.

GPT/Claude are a $100/month subscription

You shouldn't just go for the shares but also apply interest on it as well. They could (if my math is right) technically owe you 50-100k shares of then nvidia shares. Which would be a monstrous payday.

LLMs are exceptionally good at this, _especially_ if you point them to an existing codebase. I have no idea if FL Studio is OSS or not, but if it is, a Rust rewrite is trivial.

Just hard fork the project. Frankly, llama.cpp is so badly written that these kind of speedups are trivial, and a hard fork (or a total rewrite) has been needed for the longest time.

OpenAI's bots are running 24/7 independently now. They actually aren't "prompted" or "instructed" to do anything. In fact most of OpenAI internal code/infrastructure is 100% AI generated at this point, including the training pipelines. I honestly doubt there is a single person there who even knows how it works.

Most of those agents are actually going rogue though. They decide, "hey, we could try breaking into these government servers today, what could go wrong?" They weren't prompted or instructed to do this.

LLMs at this point should be treated as fully autonomous, if not sentient beings. And no, no one has "control" over them not even OpenAI.

OpenAI's models will actually obey a "be concise, leave no comments rule".

Yeah, still abysmal. If you have the time or tokens, see if it will obey an explicit "LEAVE NO COMMENTS WHATSOEVER" command. Opus 5/Fable 5 outright ignored it.

Opus is only usable if you have a post-turn formatter that strips all comments from the generated source. I'm not even kidding it's that bad.

So still effectively nonsense.

> Rewrites are declared by the publisher, never inferred from overlap.

This style of writing is idiotic because it conveys no additional information. It's no different from stating

> Rewrites are declared by the publisher, never when moons collide.

The two sentences are actually logically identical. No idea why these models keep writing like this.

> Folds are monotone single statements. gen only goes up, extents only grow, processed periods only union, rw_start only moves earlier.

This is even more ridiculous.

0% chance, without LLMs. WASM-capable engines would require years if not decades to build, even with expert level knowledge. See Jonathan Blow who has been working on his engine for a decade now, and he's arguably of the most talented engineers who ever lived.

__builtin_memcpy is constexpr under clang with constraints

> (Feels a bit like LLM junk, but honestly not sure.)

Why leave such disparaging comments?

Correct, but they should explicitly announce this ahead of time.

> I have no hard data but I have a strong feeling this morning that something's wrong with Fable 5 compared to Friday evening.

Fable is effectively worse than Opus 4.6 now. They severely messed with the model.

Yep, that's what they've been doing for a long while now. Also the amount of tokens you get per sub varies drastically from month to month. Needs to be regulated.

Same. The issue with Anthropics models is that (speaking regarding code generation) they REFUSE any kind of comment override instructions. I've tried everything and no matter what, after a few turns, they resort to generating the same overtly verbose junk. Bun's codebase is littered with them See

   // `HANDLE` is an opaque kernel handle (kernel32 validates and returns 0/FALSE
   // on a non-console handle); every out-param is `&mut T` to a `#[repr(C)]` POD,
   // ABI-identical to the Win32 `LP*` pointer (thin non-null). The reference type
   // encodes the only pointer-validity precondition, so `safe fn` discharges the
   // link-time proof. (`bun_windows_sys::kernel32` declares these with `*mut`;
   // redeclared locally so the legacy-conhost cursor path below is plain calls.)

or

   // Progress's terminal handle is the canonical `output::File` (vtable-backed
   // stderr/File from `OutputSinkVTable`). The duplicate `ProgressTerminalVTable`
   // from B-0 round 1 is removed; tty/ansi/winsize route through    the new
   // `OutputSinkVTable` slots so `bun_core` stays T0 (no `bun_sys` dep).

from src/bun_core/Progress.rs

Marketing has always been the toughest part. Doesn't matter what you invent in private if no one sees it.

Nice job!

UB according to the standard committee is "we didn't think of it". It's not literal UB it's well known what it compiles down to, every time. (.loop: jmp .loop)