(sgiannopoulos.github.io)
There's certainly eg open source audio dev material out there but not nearly as much as web dev. How else do you explain all the avalanche of vibe coded audio plugins and DAWs appearing this year?
I would assume that to a LLM, a binary executable is not much worse than actual source code. And it's much denser, just missing the semantics of human-written identifiers. It's the code's pure logic, condensed into machine language.
And there's tons of it, many vendors supply it "freely" (you don't need license keys to train on a binary) It's often battle-tested code that you wouldn't get hold of otherwise, and compared to ingested source code its unlikely that Codex regurgitates a recognizable part of a Windows 2000 DLL into your C++ source code.
So as an example, there are a bunch of different ways a for or while loop can be implemented in compiled code, but there are also situations where two quite different source constructs can result in the same machine code sequence.
Machine code certainly won't teach an LLM much about how to write good source code.
Executables are often larger than their source code.
A toolchain that creates repeatable binary builds is difficult to create. And a nonrepeatable build is potentially nondeterministic, in the sense that uncontrolled or hidden inputs impact the output.
Also it _is_ possible to gzip a file and get a larger file, there’s an inflection point based on the distribution of symbols in the source where the same compression algorithm produces a larger file than the original
Nowadays you're getting gray area stuff like new AI generated stories based in the Harry Potter universe, which is probably copyright violation but it's not actually pirated video, so Content ID doesn't spot it.
Makes complete sense to study things people actually want to use and consume
Plus, there's so much open source, and game engine SDKs, freely available, that with a few game engineers at Deep Mind, they can write training systems that connect the dots.
It's definitely a gray area because these models are doing what an indie game dev would do, but at a scale and precision that's basically pirating the game, and getting around the rules of copyright to do it legally.
No reason to belive none of the labs have similarly trained on binaries.
If it works and it's verified in nine different ways, throw it in the training pile, and then automate the process.
I imagine that someone will eventually figure out how to query black-box LLMs for copyright violations without triggering their guardrails. This is an existential threat for anyone running a black-box LLM with stolen data.
They're about to learn the hard way that the market wasn't profitable even without 10x the number of new entrants.
And that a third of the paying customer base (which was not that large to begin with) gave up on plug-ins anyway to generate finished music tracks from prompts.
By them being nothing special?
> appearing this year?
Vibe coding in general became viable last year, Opus 4.5 is Nov 24, 2025.
I chalk it up to synth and audio guys being among the more innovative users, personally - its a market of folks who have always wanted to design their own DSP/audio-graphs, and were primed for the opportunity that AI/ML presented to do so.
The same goes for the vibe-coded game communities, and as well all the retro guys.
Folks tend to not realize just how much open source is out there in fields/subjects they’re not really familiar with.
I've made a bunch of unreleased vibe-coded VST plugins to replace the hundreds that I've bought over the years - and many of the barriers to development weren't the model. Just having belief that the model was capable of the work, a bit like the 4-minute mile. Also knowing to persevere and iterate with the model, not giving up because the first UI is inevitably so amateurish.
There's also a flywheel happening. If you make permanent notes on the process, your rules for UI design, a library of re-usable components and algorithms, tools so the model can judge its own work... the whole process for the next VST just gets much faster & much easier. Same goes for any software you make with AI too.
As of this fall, you are being professionally irresponsible and SHOULD NOT be working in the field if AI is not integral to your SDLC. At a minimum it should be checking your code for bugs and vulnerabilities.
And I sort of understand what you’re trying to say in that second line, something along the lines of “the only thing that stops a bad guy with a gun, is a good guy with a gun”, right? Unfortunately it’s poorly phrased.
If AI isn’t hardening my code, then my code is very vulnerable to AI hacking from an adversary, I’ll grant that. But an absence of my AI does not cause the presence of an adversary’s AI in the way that the binary construction claims. (Compare “if you’re not with us, you’re against us”, which is a threat that says the absence of your fealty does cause the presence of my hostility.)
Likewise, I’ll grant that AI hardening my code does mitigate the damage from AI hacking, but again its presence does not cause the absence of an adversary’s AI hacking in the way your phrasing says it does.
You don't need software for that aside from the compiler/linker tools (which are free for C/C++ compilers, rust, etc.). You can then permutate/generate the source code using tools/techniques like fuzzing.
There's also things like Intel's instruction set documentation.
"Hello, we're here to see whether or not your fridge is runni-Hey, no not like that, this is serious!"
If that's what you assumed, the DeepSeek reasoning trace shatters that illusion. It's just disassembling by hand like what a human reverse engineer would do if you (sadistically?) denied them a disassembler. Yeah, the human reverse engineer would need an excellent memory of the x86_64 instruction reference, but we already know LLMs can recall a breadth of information. What we don't know, that this article also provides no evidence for, is if there will be any benefit in using the LLM for this over objdump.
The article seems to intentionally conflate disassembly (computationally cheap) with decompilation (can be computationally expensive) to imply that there's some benefit to asking the LLM to work with machine code (seems impressive to the RE layman) rather than working in assembly (something you probably already assumed LLMs can do,) but the DeepSeek trace has a disassembly in it, and it's hard to imagine that inference will ever be cheaper or more reliable per-token than objdump is at producing the same output.
So I'm actually fairly confident that the ability does come straight from the ability to read the bytes into context (usually as hex bash/perl/python3 is almost always available), and Then to directly interpret what the binary does from the code. And yes, when I do use open models, I can see from their reasoning traces that they do "hand-translate" the hex into assembly, but I kind of suspect that the translation stage into assembly may just be a narration, and the "understanding" of what is going on is actually a pure latent skill. That's just my guess, though.
The reason that I think this is because I've been using minimal implementations of inference engines. And frontier closed-weight models and open-weight models are able to observe a binary with no strings and the weights not attached, and they can infer the exact architecture and model (eg qwen3 0.6b, qwen3.5-0.8b, whatever) from the fixed shape of the inference kernels.
So in effect, over the course of 30 seconds, they go from looking at 500 instructions of x86 code and reply, “I know what this is. It's an inference engine for Qwen 3 0.6B!”
And I'm fairly sure that 30 seconds or not, it's a skill that no single human has.
But I hope you all realize that the programming language of the future is going to be for LLMs. It'll tightly optimized for LLMs and we'll get nice tools to understand them. They'll probably be great, with loads of fancy tooling.
Any other way of coding will be considered ridiculous (except maybe if you do it for a hobby).
Better start learning Haskell, folks.
But as AI proliferates and gets cheaper, why not pay to diff files. It will be sufficiently cheap.
Same for most things. How long does it take some juiced up llm to build an mp4 renderer? Can it do all of that in the milliseconds it takes mpv file.mp4 to display it's first rendered frames?
What about a video game? How long would it take the god of all AI, running on local hardware, to build and launch GTA 6? Could it do so in less than the ~4hour download and ~1 hour install? Could it do so in less than the hour install if I didn't have it installed? Could it build and launch in less than the ~minutes it would take to launch if I'd already downloaded and installed it?
Suppose in this future someone else runs their llms for many days/hours/weeks across many agents totalling perhaps years of clock time. They have a game/program that does something I'd like to do/play, and it sits in say a terabyte of space. The only way me using my agents instead of downloading their file makes sense is if I have so vastly much more compute than them that I can complete what they did in days/hours/weeks in around a day (assuming my internet somehow stays pegged to 100mb/s in this future), because I can download a terabyte in 24 hours.
Sufficiently massaged OCaml/F# approaches straightforward readability in plain English.
And, for people who have been doing it for a minute, the other ways of programming do seem a little ridiculous ;)
The boat's here. Nobody's going to be programming the old fashioned way anymore (except as a hobby or a specialist). You should probably get ready for the boat.
I haven't looked into it properly but, it looks like it might actually be the same amount of tokens? (Excepting stdlib boilerplate etc.)
Everything that can be offloaded to dumb tools should be offloaded. You don't do long division when you have a calculator. It's a neat trick, you should know how to do it, but it's not very practical.
Nope.
000001?
Nope.
...
000000 00001 00010 00110 00000 100000?
Hey, we've got addition!
And the proof of course is that I can reassemble/link, with "modern" tools, their presented assembly and it combines right back into a hex dump mirroring the original.
Anyway, it's been a joy to take the long-out-of-print book, "The First Book of KIM", and re-typeset it (re-assemble it?) for modern hobbyists like myself. LLMs have allowed me to clean up the poor OCR-extracted text from the original. Claude has not only done that, but found missing labels and "equates" in the assembly, as legitimately printed in the book—not OCR errors.
Heck, Claude latched on to a bug in the classic "WUMPUS" game that apparently the author was not even aware of. (But I left that bug in for hobbyists to find—or exploit.)
Now think about homomorphism and safety filters……
This process would normally require a human to lift bytes -> ASM, ideally ASM -> obfuscated source, making sense of it, and doing the chain backwards, and it requires coordinating a lot of knowledge. Which of course is no problem for an LLM.
2. Binaries are 1 to 1 direct representations of the assembly code they are created from. If you know the instructions set it isn't black magic to figure what byte means what.
Why on earth would it be better for llms to program in binary or assembly. We have optimizing compilers so the effort doesn't need to be spent there.
Maybe my assumptions are wrong, so please correct me.
Edit: but yes, in general it's utterly amazing I can ask computer to tell what a computer program does, even a binary file.
I mean decrypted data of course, because it surely couldn't learn directly from encrypted data, right? Right?
They don't list any model size or version that failed, right?
PS: and it also has no problem writing a simple 'bouncing sprite' C64 demo without going through assembly and wrap that in a .prg file (of course this is basically the 'hello world' of C64 demos and could be as-is in the training set).
Let's see if the data URL survives HN:
https://floooh.github.io/tiny8bit/c64.html?file=data%3Aappli...
[0] is the episode I'm referring to, but the whole series of videos about his woes with this bike are quite interesting.
Pet peeve: Using AI to solve problems that existing algorithms can dependably solve with 10^-6 the CPU resources.
Disassembling directly an executable program, especially when it is some proprietary program for which there is no debugging information, is likely to produce a lot of garbage that does not correspond to correct assembly instructions.
Correct disassembly can be obtained only by simulating the execution of the program and disassembling only the instructions that are reached in this way. This is still not completely foolproof, because during simulation some parts of the code might be reached only for some specific input data, which is unknown. Sometimes one may guess all the possible inputs and disassemble anything reached in this way, but in reality some of those inputs can never occur, which can lead to erroneously disassembling parts that should not be disassembled, as they are not instructions.
That said, most executable programs are easy to disassemble, but some may be intentionally or unintentionally very obfuscated, and for such cases any disassembling tool would have to be guided by a human to achieve a complete disassembly.
In your comment you're talking about reverse engineering.