LLM assisted reverse engineering
TL;DR Highlight
Pointing an agent at binaries with skills and MD notes made years-long hacks feasible
Who Should Read
A developer whose coding agent keeps repeating the same guesses while debugging and wasting time
Core Mechanics
- Point the agent at the binary and add skills
- First identify binary type, platform and build, then pick a suitable decompiler.
- The author says current AIs do fairly well with just raw x86 or ARM disassembly.
- Make the agent log findings to MD files
- The notes help you understand the target.
- They keep the agent on track after compaction or handoff to another agent.
- They also reduce circling in the same spot.
- When stuck, give a specific alternative approach
- For example, if xref-following stalls, tell it to follow strings in the binary instead.
- Debugger breakpoints, injected logging probes, and outside access like computer use or an emulator also help.
- A hypothesis-debugging skill stops guessing loops
- Write a hypothesis into a CSV file on disk.
- Design an experiment (probe, logging) that definitively proves or disproves it, record the result, and repeat.
- The author calls this crucial and published it.
- Write RE tooling usage into skills
- The author says without a tooling skill, agents get lost and give up too quickly.
- Describe how to use the Ghidra MCP bridge, radare2 and kuna.
- Split implementation: Python (uv) and Rust
- Probes and decompilation helpers are single-file Python scripts via uv.
- The actual hack is written in Rust because the strict compiler gives the agent fast feedback.
- Read the agent's conversation and thinking
- Spot blind paths and suggest a better approach.
- The author says this takes your own experience.
Community Reactions
- Guessing loops are the main annoyance
- A commenter doing RE with Opus 4.8 has to keep telling it to stop guessing on harder targets.
- They argue most cases have enough info to reach answers deterministically with meticulous work.
- Unicorn emulation harnesses for firmware
- A commenter says having the LLM write harnesses for bootroms and firmware is a big win.
- It handles the loop of finding which MMIO to stub next, though it sometimes takes shortcuts that defeat the purpose.
- IDA Pro over Ghidra, and report-based context resets
- A commenter finds IDA Pro works better with LLMs.
- Their tip is to have the LLM periodically write reports, wipe the context, and restart with the report.
- Android apps worked without extra skills
- A commenter had Codex unlock premium features of subscription apps and reimplement them offline.
- Another comment notes context is always a problem because too much info is lost.
- Legal, ToS and guardrail concerns
- A commenter says OpenAI and Anthropic models complain about RE requests.
- Others warn that agreements like Apple's developer agreement can forbid RE, and ask about patent liability.
- One commenter says AI use takes away the satisfaction of the process.
How to Apply
- Add a notes-file rule to your agent
- Put an instruction in your agent's system prompt or AGENTS.md to log findings to findings.md continuously.
- When the conversation gets long, clear context and resume from that file only.
- Apply the hypothesis CSV loop to stuck debugging
- When the agent repeats the same attempt twice, make it log hypothesis, experiment and result in hypotheses.csv.
- Allow only experiments such as logs or probes that can decisively settle the hypothesis.
- Write a tooling skill file
- Describe when and for what to use your tools (Ghidra MCP, radare2, etc.).
- Adapt the author's ghidra-decompile-skill repo to your environment.
- Give stuck agents a concrete alternative path
- Name the failing method and the replacement together (e.g. stop xref-following, retry from strings).
- Read the thinking trace and intervene when it heads down a dead end.
Try It
# Paste into a coding agent such as Claude Code or Codex (simplified prompt version of the article's method)
You are analyzing {{target: binary/bug/feature}}. Follow these rules.
1. Record every finding immediately in findings.md.
2. When stuck, do not guess; write one hypothesis line in hypotheses.csv (columns: id, hypothesis, experiment, result).
3. Design and run only an experiment (logging, probe, breakpoint) that definitively proves or disproves it, then record the result.
4. If the same approach fails twice, switch approach (e.g. follow strings instead of xrefs).
Start by analyzing the basic structure (main functions, branching, imported functions) and summarize it in findings.md.
Next to try: clear the conversation midway, feed it only findings.md, and check whether work continues.Terminology
Related Papers
Metrics-in-the-Loop: Complexity Feedback Reshapes Agent-Written Code
Injecting per-turn complexity reports into coding agents cut code erosion without changing correctness
Why is Gemini 4 Carbon taking so long?
Carbon took nearly an hour on bug fixes that Astra and Opus finished in minutes, mostly from extra unrequested work.
How the Claude Code team thinks about verification
E2E, property and differential tests plus verification rules let Claude run in parallel.
Running coding agents without handing them my credentials
Credentials stay on the laptop; agents run commands there via Touch ID approval
Windows 11 Is Collecting Data on Which Coding Agents and Developer Tools You Use
Reverse engineering shows Windows 11 logs which coding agents you use and reports it as optional diagnostics
The Silent Cost of Conversation History in LLM Reasoning
Keeping full conversation history dropped accuracy from 0.6 to 0.1 within 20 turns; a verified state summary prevented it.
Anthropic upgrades Claude Code Projects to run parallel AI workers
Claude Code Projects now has a coordinator that splits work into parallel threads and opens PRs.
Show HN: AgentRun – open-source, Self-improving Managed Agents
Agents save notes and skills after each run, cutting code review cost to 18 cents