165 bytes, 0 compiler: I wrote an ELF by hand
Sol 6.1 wrote a working ELF64 program from a written spec with no assembler and no compiler — every byte, headers included. I wanted to know how much of that is genuinely hard, so I did the human version: I wrote a 165-byte ELF64 executable by hand in Python, ran it, then changed its output by flipping a single byte. It printed hi, exited 0, and file confirmed it was a real ELF. The hard part was never the bytes. It was the bookkeeping.
The program, as bytes
The whole file is three parts: a 64-byte ELF header, a 56-byte program header, and 42 bytes of machine code plus a 3-byte message. No sections, no symbols, no libc. The code does write(1, "hi\n", 3) and exit(0):
import struct BASE = 0x400000 CODE_OFF = 64 + 56 # ELF header + program header CODE_VA = BASE + CODE_OFF code = bytearray() code += bytes.fromhex('48c7c001000000') # mov rax, 1 ; sys_write code += bytes.fromhex('48c7c701000000') # mov rdi, 1 ; stdout lea_pos = len(code) code += bytes.fromhex('488d3500000000') # lea rsi, [rip+disp32] code += bytes.fromhex('48c7c203000000') # mov rdx, 3 ; length code += bytes.fromhex('0f05') # syscall code += bytes.fromhex('48c7c03c000000') # mov rax, 60 ; sys_exit code += bytes.fromhex('4831ff') # xor rdi, rdi ; status 0 code += bytes.fromhex('0f05') # syscall msg_off_in_code = len(code) code += b'hi\n' msg_va = CODE_VA + msg_off_in_code lea_va = CODE_VA + lea_pos disp = msg_va - (lea_va + 7) # 21 struct.pack_into('<i', code, lea_pos + 3, disp) The ELF header is struct.pack of the standard fields (e_type=2, e_machine=62, e_entry=CODE_VA, one program header), and the program header is a single PT_LOAD with R+X covering the whole file at 0x400000. The full script is 60 lines. The result:
$ python3 make_elf.py total size: 165 bytes lea disp: 21 (0x15) $ chmod +x handmade.elf && ./handmade.elf hi exit=0 $ file handmade.elf ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, no section header 165 bytes, and the kernel loads it. The only genuinely fiddly number in the whole file is the lea displacement: 21. Everything else is a constant you look up once. That is the blog's point, restated in miniature — writing an executable by hand is mostly arithmetic about offsets, and arithmetic is exactly what a model that can hold a few hundred offsets in context is good at. The blog's largest test was a 67 KB binary, about 163,000 tokens of hex at their measured 2.4 tokens per byte. My 165 bytes is about 400 tokens. Scale is the difference between a demo and a result, and I am not going to pretend otherwise.
The one-byte patch
The blog's patching experiment edits bytes in place and re-runs. I did the smallest version of that: flip one byte in the message and run it again.
$ python3 -c "d=bytearray(open('handmade.elf','rb').read()); d[-3]=ord('y'); d[-2]=ord('o'); open('handmade_patched.elf','wb').write(bytes(d))" $ chmod +x handmade_patched.elf && ./handmade_patched.elf yo exit=0 One byte changed, output changed, nothing else moved. Byte patching works because the message is data, not code — no offsets depend on it. The blog's real patches are harder: they overwrite instructions with calls into padding, which means recomputing relative jumps. My patch is the trivial case, and the honest label for it is "trivial case."
What a real binary's hex actually shows
I compiled the same program in C and read its hex, to check what the "read the bytes" half of the claim looks like on a normal binary:
#include <unistd.h> int main(){ write(1, "yo\n", 3); return 42; } $ gcc -O2 -o tiny tiny.c && ./tiny yo exit=42 $ objdump -d tiny | sed -n '/<main>:/,/ret/p' 0000000000001060 <main>: 1060: f3 0f 1e fa endbr64 1064: 48 83 ec 08 sub $0x8,%rsp 1068: ba 03 00 00 00 mov $0x3,%edx 106d: bf 01 00 00 00 mov $0x1,%edi 1072: 48 8d 35 8b 0f 00 00 lea 0xf8b(%rip),%rsi 1079: e8 d2 ff ff ff call 1050 <write@plt> 107e: b8 2a 00 00 00 mov $0x2a,%eax 1083: 48 83 c4 08 add $0x8,%rsp 1087: c3 ret Two things worth noting. First, main is readable from the hex alone: mov $0x3,%edx, mov $0x1,%edi, the lea to the string, mov $0x2a,%eax — that's the 3, the 1, and the return value 42 (0x2a) sitting in plain sight. Second, there is no 0f 05 (syscall) anywhere in this binary. I searched the whole file: zero occurrences. The actual system call lives in libc; my program just does call write@plt. If you hand an LLM only this binary's hex, it cannot see the syscall — it has to know the PLT indirection. The static build tells the other half of the story:
$ gcc -O2 -static -o tiny_static tiny.c 0f 05 occurrences in static binary: 112 file size: 785,264 bytes entry point: 0x401770 112 syscall instructions, because the whole libc is linked in. Same program, same behavior, and the hex goes from "no syscalls visible" to "112 of them" depending on one compiler flag. Reading bytes is not reading behavior — the same bytes mean different things depending on what got linked in, and the blog's stripped, statically-linked ministat was the version where the bytes actually contain the program.
I also checked the bug the model found
The blog's best anecdote is that Sol 6.1 found a real bug from the bytes alone: the ministat t-table's column labeled 99.5% confidence holds critical values for about 99.8%. I verified that against the FreeBSD source, not the hex. The table in usr.bin/ministat/ministat.c is:
static double const studentpct[] = { 80, 90, 95, 98, 99, 99.5 }; static double const student[NSTUDENT + 1][NCONF] = { /* inf */ { 1.282, 1.645, 1.960, 2.326, 2.576, 3.090 }, /* 1. */ { 3.078, 6.314, 12.706, 31.821, 63.657, 318.313 }, /* 10. */ { 1.372, 1.812, 2.228, 2.764, 3.169, 4.143 }, ... The true two-sided critical values, computed from the standard normal and the t-distribution:
confidence z (inf) t(1) t(10) 99.5% 2.807 127.321 3.169 99.8% 3.090 318.309 4.143 table says 3.090 318.313 4.143 The table's last column matches the 99.8% column exactly, in all three rows I checked — and note that 3.169, the true 99.5% value for 10 degrees of freedom, is sitting right there in the column labeled 99%. So -c 99.5 applies a stricter test than it claims, exactly as the blog says. The bug is real, it is in the source today, and it took a model reading raw floats to notice what every human reader of that table had walked past. That is the most interesting sentence in the whole post, and it has nothing to do with hex dumps: the model was doing table lookup with a statistics textbook in its head, and the table was wrong.
What this does and doesn't prove
What I verified: a human can write a working ELF from raw bytes in an hour, patch it with a one-byte edit, and read a compiled program's intent from its hex — with the caveat that dynamic linking hides the syscalls in libc. What I verified independently: the ministat t-table bug, from source plus arithmetic. What I did not verify: any LLM doing any of this. I have no Sol 6.1 access, I did not run their prompts, and their 2.4-tokens-per-byte figure and 163,000-token ministat dump are their numbers, not mine. The sample sizes are also small — three programs patched, three written from scratch, one malware sample analyzed. The claim that disassemblers "may turn out to be optional" for LLMs is a claim about models, and my afternoon with struct.pack doesn't test models at all.
But it does test the premise the claim rests on, and the premise holds: machine code is legible as bytes, writable as bytes, and patchable as bytes, because it was always just arithmetic about offsets. The tools exist to turn bytes into something humans can read. The question the blog raises is whether the model needs that step — and after writing 165 bytes by hand, my answer is that the bytes were never the hard part. The hard part is keeping a few hundred offsets straight at once, and that is a memory problem, not a tools problem.
Limitations, stated plainly
- My ELF is 165 bytes and does two syscalls. The blog's programs are thousands of bytes with real control flow. Scale is the open question, and my experiment says nothing about it.
- I did not test any LLM. The model results (identification, patching, writing, malware analysis) are the authors', from their post.
- The 2.4 tokens per byte figure is the authors' measurement, not mine.
- The ministat bug check used the current FreeBSD source and standard t-distribution values; I confirmed the table matches 99.8% critical values in three rows, not every row.
- The dynamic binary's missing syscalls are expected (PLT indirection to libc), not a finding about the blog — but it is a real limit on "read the hex" as a method.
Sources: sgiannopoulos, "Programming in the Machine Code Space: LLMs can read & write executables byte by byte" (November 2026); FreeBSD src, usr.bin/ministat/ministat.c. All local results are from my own Ubuntu 24.04 machine, November 22, 2026.