Hobbyist hacker shares his LLM agent workflow for reverse engineering

In a personal blog post titled "LLM assisted reverse engineering", an author who does not give a name says he has hacked hardware and software for two decades, first by hand. In 2026, he writes, AI has greatly sped up the process. His usual routine is to point an agent at the binary to be analysed and apply his own set of dedicated agent skills; the rest, he says, usually takes care of itself.

The flow starts by finding the binary type, platform and build, then choosing a suitable decompiler. He notes that current AIs do fairly well with disassembly alone, meaning pure x86 or ARM instructions. Next he tells the agent to document every finding along the way in Markdown files. By his account they serve three purposes: they are notes for the human, they help the agent keep its place after context compaction or a handoff to a different agent, and they keep the agent from getting lost in circles. Then he asks the agent to analyse the basic structure: main functions, main branching, imported functions. The "binary" can be a desktop executable, a website or a firmware image. With that overview he can go on to modify the binary, build mods or simply understand it better.

When disassembly or decompilation is not enough, he lists several fallbacks. The agent can debug the binary and set breakpoints. It can use logging, either by enabling it in the original binary or through a probe injected into it that writes what is needed to a file. It can be given outside access, such as computer use for desktop apps or an API-controllable emulator for firmware. He also asks it to try a different approach, but says the instruction must be specific: if the agent is stuck following cross-references in the disassembly, tell it to follow strings in the binary instead. Finally, he reads the whole LLM conversation and its thinking. Current LLMs are smart, he says, but sometimes take a narrow approach, and the traces often show when the agent is heading down a blind path so he can suggest a better one. He adds that this is a skill the human has to have.

He then describes three major skills. The first is headed "Matt Pottock - Grill me"; it asks the user several questions when the user's input might be valuable. He says he usually uses it with a prompt, but the prompt is not reproduced in the text. The second is a reverse engineering tooling skill that describes his specific tools, for example radare2 or kuna, or how to use the MCP Ghidra bridge and for what. Without it, he says, agents often give up too quickly, lost and unsure how to actually disassemble or decompile. The third is his own "Hypothesis debugging" skill, which he calls crucial. It forces a stuck agent into a loop: write a hypothesis of why or how something works into a CSV table of hypotheses saved on disc, design an experiment (a probe, logging) that will definitively prove or disprove it, record the result, and repeat. He calls this a variation of the scientific method that stops endless guessing and random trial and error, and says he made the skill public.

For implementation he uses two toolchains. Python with UV is for prototyping, quick probes and decompilation helpers; UV makes custom environments quickly and portably and allows single-file scripts with inline dependencies. Rust is for the actual implementation of a hack, whenever possible. His two main reasons: he finds it elegant to work with, and its very strict compiler gives the agent brutally good feedback loops by pointing at memory or syntax issues immediately. He concedes Rust has downsides such as slower compile times, but says it is mature and has many build targets; he says he has used it for web apps, desktop apps, hacks and trainers, and firmware for embedded devices.

The post lists his "hacking successes" from the last 6 months, which he says would each have taken years by hand: reverse engineering and hacking the Alphasmart NEO typewriting device; mapping the communication protocols of devices such as the EmWave biofeedback device and his two Sony Alpha mirrorless cameras, which let him build custom desktop and mobile apps for file transfer and wireless control, including a wireless webcam from his A7III; developing custom firmware for the Arturia MiniFreak, Teenage Engineering OP-Z and Akai MPC Sample synthesizers; custom firmware for the Xteink X4 ebook reader; a fixed driver for an old HP printer on macOS; cracking tons of license-locked abandonware from his youth; and a custom lightweight Evernote client. He adds that the line between reverse engineering and software development is thin: after deciphering the proprietary save format of a paid app, he built a custom Photoshop-like editor, which he says is not the ArtCraft suite and which he made about a year before it, just for himself.

In his closing thoughts he says reverse engineering old software and devices has always been a hobby, but used to be long and tedious. He does not miss manually analysing assembly and loves getting results quickly. His long experience helps him steer the agents the right way, and he is learning a lot along the way. He hopes everyone tries some hacks of their own and says LLMs did not take away his curiosity but gave it a turbo boost.

Key facts

  • The author, who says he has hacked hardware and software for 2 decades, points an LLM agent at a binary and applies his own agent skills; he says AI greatly sped up the process in 2026.
  • Core habit: the agent must document all findings in Markdown files, which keeps it on track after compaction or handoff to another agent.
  • His "Hypothesis debugging" skill makes a stuck agent record a hypothesis in a CSV table, design a definitive experiment, record the result and repeat; he says he made it public.
  • He prototypes with Python and UV and writes the actual hacks in Rust where possible, because the strict compiler gives the agent fast feedback.
  • He lists hacks from the last 6 months, including firmware for the Arturia MiniFreak, Teenage Engineering OP-Z, Akai MPC Sample and Xteink X4, and says each would have taken him years by hand.

Why it matters

The post is a concrete, practitioner-level account of how an experienced reverse engineer hands the slow parts of the job to an LLM agent. The author's claim is that work which once took years per project now fits into months across many projects. The most reusable ideas are procedural rather than model-specific: keep a written trail in MD files, give the agent a skill that describes the reverse engineering tooling, and force a stuck agent through a hypothesis and experiment loop.

Who it affects

Hobbyists and professionals who reverse engineer binaries, firmware images, devices and old software, and anyone building agent skills for long, exploratory technical work. The author's examples span desktop executables, websites and firmware, and consumer gear such as cameras, synthesizers and an ebook reader.

How to use it

The author's recipe: identify the binary type, platform and build, then pick a decompiler (disassembly alone often works). Have the agent write findings to MD files as it goes, then ask for the basic structure: main functions, branching and imports. If it stalls, let it debug with breakpoints, add logging or an injected probe, give it computer use or an API-controllable emulator, or redirect it specifically, for example from following cross-references to following strings. Read the agent's conversation and thinking to spot blind paths. Keep a skill describing your RE tooling (radare2, kuna or the MCP Ghidra bridge) and a hypothesis-debugging skill. Use Python with UV for probes and Rust for the final implementation.

How solid is it

This is a first-person blog post with no benchmarks or measurements. The source gives no measurements or benchmarks of the speedup: "years each" is the author's own estimate. It gives no dates, durations or detailed results for any individual hack, and nothing in it says the claims were independently verified. The author is not named in the text, and the list of tools he mostly uses is empty in the published text, so no specific model, agent or decompiler is identified as his main setup. Treat it as a credible practitioner's account of method rather than evidence of results.

Risks and caveats

The author stresses that his two decades of experience help him steer the agents correctly, so results may not carry over to a beginner. He also says agents get lost or give up without a tooling skill, can follow a narrow approach, and need specific guidance and human review of their reasoning traces. He notes Rust's downsides, such as slower compile times. The source does not say whether any of the hacked devices or cracked software raised legal or licensing issues, even though the list includes cracking license-locked abandonware.

“LLMs didn't take that away. They gave me turbo boost to my wonderings and explorations.”

— Author of the post, slowchronicle.com