What I ended up with was a port of Duke 3D that uses half the allocated RAM as DukeGDX.

My custom IDA CLI is just a simple thing on top of IDA Python's integration + ida-domain + some higher-level helpers, and works as a daemon with workers, so a stale/bad request doesn't corrupt an IDA DB (an issue I had when I was using idasql).

A bit offtopic, but: do you have any links to your efforts? I'm curious to see what other people do in this area.

This is quite the understatement. Actually, it's probably the understatement of the year.

"Pretty good, not bad, great use case".

Dude. Fable fucking did what?

It works great just like that.

Seems doubtful, I'd put money on it being something like Visual Studio or Visual Studio Code. Maybe CC could claim the (odious) title of most actively used vibe-coded development app, though.

Blogposts were promised, details were hinted, but no, it’s just full steam ahead because the AI worked so well. The converted unit tests all worked, all the synthetic tests are okay, so what are you complaining about?

At some point, it’s less about the technical questions and more about getting that pesky human buy-in.

- I don't think Claude Code is using the Rust version yet in their official build

- Claude Code is not a particularly complicated piece of software from an engineering perspective (nor it's particularly well-engineered, at least at the moment).

So in my book "it runs Claude Code" would be pretty weak evidence that the rewrite is going to be successful (the tests they've done are much better evidence, but that's a topic for another time).

Huh... it looks to me like bun has yet to cut a release post Zig->Rust port (the latest one on github is still on a branch that says it's written in zig in the readme). I assume that nothing is using the rust version yet...

Which also cuts against the complaints about "of course it works [...] you can put this into your production environment soon!" since they don't seem to be asserting either of those things.

I... somehow did not know that.

It's a thing in some Germanic languages. Instinct is to merge nouns into word, e.g. 'lawnchair', but that gives you a red squiggly line, but 'lawn chair' also looks wrong, so 'lawn-chair' is the middle ground.

I don’t think it’s easy on native speakers when it happens, but it’s even harder when you’re not.

--- AGENTS.md ---

## Plain words, not jargon

Don't use jargon-as-shorthand. Say what you actually mean.

- Don't say "load-bearing assumptions". Say "the assumptions the xyz depends on".

- Don't say "cross-service". Name both services, e.g. "whether the X service can derive duration without calling the Y service". "Cross-X" is confusing because it hides which things are involved.

- Don't deliver verdicts as abstract noun-phrases like "Cross-RCA double-counting is unfounded". Say it plainly: "I checked whether the same root cause gets counted twice across RCA runs, and it doesn't."

## No earth-shattering declarations

Don't hype findings. Skip "a critical finding changes everything", "now I have the full picture", "this changes the game", etc. Just state what you found plainly. Most findings are ordinary; report them that way.

## Don't reflexively hedge a "yes"

When the answer is yes, say yes. Don't soften every positive answer with a caveat: it erodes confidence in the "yes". Only add a caveat when there's a genuine, specific uncertainty worth flagging.

Then recently I found https://github.com/bkerler/ida_rpc which seems to be ~60% the same thing as the one I have, the only big difference is that I do not give any special commands to LLMs, they just have to write Python in scripts/inline heredocs to interact with IDA. This lets them do a lot more interesting things since they get a full programming language.

This is an example of how LLMs work with idagent (`ida` is implicitly imported, ida.types, ida.comments is helper's own wrappers): https://paste.debian.net/hidden/cf46a122

More interesting example that was used to let the LLM/me track the rename progress for the initial function renames + gaps (code-looking like bytes that weren't inside of functions, IDA's autoanalysis missed some real functions). Although the game turned out to be small enough with only ~1500 real game functions that needed renames, which was done in ~10 hours of agent time total I think (I didn't parallelize with multiple agents). https://paste.debian.net/hidden/bf458b3a

To be honest, you can probably have an agent vibecode a similar tool to the one I have in about an hour :)

"Yes, the AI rewrote the code. No, we do not pretend that we've scrutinized the code, or that we understand it. It works, tests pass, so we don't care, and so shouldn't you."

The "recklessness" is offered as the new normal. Because it kinda, well, works for them.

No, I'm pretty sure it is, actually, since June 17:

https://code.claude.com/docs/en/changelog#2-1-181

>> Upgraded the bundled Bun runtime to 1.4

Now, Bun 1.4 doesn't seem to officially exist on https://bun.com/blog or https://github.com/oven-sh/bun/releases, so I can't be 100% sure this is the Rust version. However, I have to do some patching of the Claude Code binary to get it to run on my OS, and version 2.1.181 coincided with some changes that make suspect it's using Rust now.

When someone on another social media platform commented expressed some concern, his response was to ask him what the explicit bug he was talking about was and that he would generate a fix. That sound you hear is the woosh as the point flies by. And in general, this just feels like a consistent problem with Bun.

The problem is what comes next. They now have code that they don't understand, and they are likely to work on it with AI in the future, but the new features they may introduce later will not have the luxury of hand-written tests and a reference code. So, unless they undertake the massive effort needed to fully understand the Rust code and deal with all these "unsafe", quality is very likely to go down, Microslop style.

There're some D3D implementations over Metal that could skip the Vulkan layer but none implement the old D3D8 so you'd still need another layer that implements e.g. D3D8 over D3D9-11. Also, DXVK and MoltenVK have got a lot of traction and fixes on their own, so they're probably the most accurate pipeline for D3D on Metal.

No, it’s good. When they stop doing this, it’ll be harder spot the machine slop.

Also they're probably interested in the team just as an acqui-hire of good developers, and they're probably interested in the marketing value of converting the actual bun to rust via LLMs. But mostly I'd assume it was about needing the team to effectively direct the LLMs.

The problem is: quickly fixing problems (or preventing problems) benefits from having a good understanding of what the code is doing.

If you do have a suite of automated checks that's comprehensive enough that if it passes, no one will have any problems with the result, I think I'd agree. -- I don't think we're quite there at the point where "programming" is coming up with that suite of automated checks and then just not regarding the source code of the program itself.

Still, it represents a possible way how AI gets rid of team members.

> "now I have the full picture"

I always interpreted that phrase as a sort of marker to delimit the phase in which it explores the codebase and gathers information from the phase in which it implements the changes.

Not sure if it's still done, but I think some months ago there was discussion that some of the phrases are injected by the inference loop to "steer" the model - e.g. "But wait" if a thought block was too short etc. Obviously such phrases couldn't be influenced by the prompt.

  "The evening settled over the city, drawing the light out of the streets one corner at a time. Windows blinked awake with lamplight, and the wind moved through the alleys restlessly, leaves brushing against walls before gathering themselves along the pavement. In the distance, the river kept its steady argument with the stone embankments. When the night pressed in, the weather became increasingly angry, until it was a raging storm."

But such personification is a natural part of how the English speak.

https://grigio.org/bun-1-4-the-controversial-ai-driven-rewri...

> 13,044 unsafe blocks in the resulting Rust code (hand-written Rust projects of similar size average ~73)

Grok is this true?

I've heard the meme that AI written rust code is absurdly full and safe blocks but... that's pretty funny.

Hang on. A claim like that can be verified with a single grep! Give me a minute...

    $ rg -U "unsafe\s+\{" . | wc -l
    10551

And if you manage to do this automatically before committing, you’ve built the backpressure everybody is talking about.

Last I heard Claude Code devs were trying to compare their app to a game engine or rendering system.

This was summarily ridiculed. Are you saying that writing a game engine is easier than writing Claude Code?

Life was different back then. Source control systems were a LOT worse (this is CVS era for open source development). We certainly weren't in the current era where everyone wants to play these old games on their phones now.

What almost certainly happened is all copies of the source were simply lost. They may have sat on someone's hard drive, a team server hard drive, or somewhere else. It's possible they didn't have more than a few copies while development was ongoing.

The high number of unsafe blocks is a good sign.

If I understand what happened here correctly this isn't really a case of any such meme, but the result of the porters (heh) telling the LLM to directly convert zig code using unsafe to match the previous code "exactly".

I.e. more like using the LLM as a fancy version of c2rust [1] (which would result in just as much unsafe) than a result of LLMs reaching for escape hatches too liberally.

[1] https://github.com/immunant/c2rust

But it didn't, thats the whole point. The game in question was updated like a day ago, not 20 years.

Fable added few config files for iOS and a gesture mapping to mouse events. It did not do any of the hard stuff.

The title is so misleading that it is probably the single reason why this made to the front page with people assuming it actually did anything hard here.

If anyone deserves the recognition - its the upstream projects that made the game modern and cross platform in the first place.

EA Games open sourced the original C&C Generals source code a year ago.

GeneralsX is a fork of the original source code. The fork changes the code to be easier to be ported to other platforms, which GeneralsX provides native Linux and macOS builds.

This project adds a iOS target for the GeneralsX project, the iOS port was made using Claude Fable.

It is cool that a LLM was able to create a iOS port? Yes, but saying like if it was something that was hard or that it would take too much time to do before LLMs is a bit disingenuous in my opinion, especially because the GeneralsX had already done the bulk of the effort of making the code portable in the first place, and that there was already a macOS port.

For reference, the iOS port only needed to add 2,179 lines of code on files that already existed on GeneralsX, and that's not excluding comments, which Claude loves to add some LARGE comments, and things that are iOS app specific, like the app's Info.plist.

And probably that should be run in different harness or with custom system prompt? Since they introduce quirks and glitches as well.

(somehow this motivated me to resurrect HN account)

still very cool, and sci fi not long ago

I often tell codex to launch a subagent without prior context to „remove BS phrases and make the prose sound more natural and higher readability“. That‘s usually enough to get better results.