Can AI Reverse Engineer Anything?

Yes — with one important correction. AI cannot reverse engineer anything, and neither can a human. What AI changed is the pace: with the right tooling, an agent can take a feature you can only observe from the outside and hand you evidence-backed pseudocode, a traced call path, and a working reimplementation in the time it used to take to open a debugger.

This post walks through the method behind morluto rea (an open-source MCP server built exactly for this), then shows how to run the same workflow through AI Powered Coding Assistant — from reading decompiler output to shipping code that actually compiles.

The Short Answer

• Behaviour, JavaScript/Electron apps, .NET assemblies, websites, HAR captures, process output: AI handles these well today, often without any native analysis engine.
• Native binaries, firmware, Android APKs, WASM, EVM bytecode: AI can drive the analysis, but it needs a real disassembler behind it (Hopper, Ghidra, or IDA).
• Heavily obfuscated, packed, or legally off-limits targets: no, and you should not try. The bottleneck was never can the model read assembly. It was workflow: knowing which surface to inspect, keeping the evidence attached to each conclusion, and turning a half-readable decompile into something that runs.

What Reverse Engineer Anything Actually Means

What REA Is

REA is an MCP server that connects your coding agent to tools for inspecting native binaries, JavaScript and Electron apps, .NET assemblies, and websites. Its own one-line pitch is blunt: See a feature you like. Understand how it works, down to the binary level.

Two properties matter more than the feature list:

1.Analysis runs locally. Your files, dumps, and captures do not leave your machine. 2.Results carry evidence and limitations. Every conclusion comes with the material behind it — so you can check the reasoning instead of trusting it. Setup is one command (npx rea-agents setup), which registers the MCP server with your agent and installs matching workflow instructions. It supports Claude Code, Codex, Cursor, Gemini CLI, Grok Build, and any other client that speaks local MCP. The repo is MIT-licensed and, as of writing, shows 123.1k stars and 27.7k forks — a signal that the let the agent do the archaeology workflow has gone mainstream.

The Old Workflow vs. the Agent Workflow

The traditional path: open a disassembler, read a few hundred functions, guess at the boundary between the part you care about and everything else, give up, ask a colleague who has seen this codebase before.

The agent path: describe the question, let the agent pick the inspection surface, trace the code, and return findings with evidence. REA's own documented example prompt is exactly this:

Understand how search works in the Notes app, show me the evidence, and build a similar feature for my project. The last clause is the one most people skip. Reverse engineering that does not end in working code is a hobby, not a job.

The REA Method: Six Habits That Make AI Reverse Engineering Work

1. Start With a Question, Not a File Do not hand the agent a 200 MB binary and say figure it out. Hand it how does this app compute sound panning for a moving ball? Narrow scope is what keeps evidence traceable.

2. Pick the Surface Before You Pick a Tool Different targets need different instruments. REA's documentation separates them explicitly — native binaries return pseudocode, assembly, strings, symbols, calls and references (via Hopper, Ghidra, or IDA), while JavaScript/Electron analysis returns modules, imports, source maps, routes, IPC, and native add-on relationships, and needs no native engine at all. Choosing wrongly wastes hours.

3. Demand Evidence for Every Claim An uncited this function is responsible for X is a guess. A quote of the actual instruction, string, or IPC channel is a finding.

4. Trace the Boundary, Not Just the Function The published Notion case study is the cleanest example: the renderer's clipboard API was followed through preload and IPC into the main process, then the rich clipboard format was inspected. The valuable output was not one function — it was the map of how two processes talk.

5. Turn Pseudocode Into Real Code — and Prove It Two showcases in the repo show what verification looks like:

6. Record the Limitations Analysis complete is not a finding. Here is what I could not resolve, and why is.

What AI Can and Cannot Reverse Engineer Today This is the list REA actually documents support for, so treat it as the current honest boundary:

Anything outside these surfaces is still a research project — and the more a binary is packed or obfuscated, the more the human work dominates the AI work.

Where the Method Stops and the Work Starts

Here is the practical problem with a pure agent run: REA returns pseudocode and assembly. That is evidence, not a codebase. You now have to read it, normalise it, make it compile, and be sure you did not silently break the maths while porting it.

That second half is where an Online AI Powered Coding Assistant earns its place. AI Powered Coding Assistant exposes eight task modes — Generate Code, Translate Code, Explain Code, Review Code, Fix Code, Regex Generator, Diagram Generator, and Cron Expression — and the reverse-engineering workflow uses six of them in sequence.

Step 1 — Explain Code:

Read Decompiler Output in Execution Order Paste the pseudocode the agent dumped for you. Choose Explain Code. What you want back is a step-by-step walkthrough in execution order, with non-obvious logic, magic numbers, and hidden side effects flagged — the things a one-line comment would never capture. Those flags are exactly the spots where a porting bug is born.

Step 2 — Translate Code:

From Assembly-Flavoured C to Code You Can Ship Decompiler output is legal C, but it is not readable C. Translate Code is the step that converts a register-shuffling mess into idiomatic, reviewable source in the language you actually build in — and it is also how you move a recovered JavaScript routine into Python, or a C# routine into Go, without re-deriving the logic.

Step 3 — Fix Code:

When the Reconstruction Doesn't Run The demo README is honest that the pseudocode is incomplete. So your first build will fail. Paste the compiler error plus the translated function into Fix Code: you get a root cause, a corrected version, an explanation of why the fix works, and a regression test that would have caught the bug — which you then reuse as the porting harness.

Step 4 — Review Code:

Audit Before You Ship This is the step engineers skip and later regret. Run Review Code over your reimplementation. Findings come back rated blocker / major / minor, each with a concrete fix snippet. For reverse-engineered code, treat every blocker as a place your reconstruction may be semantically wrong rather than merely untidy — that distinction matters when you are copying behaviour you cannot see the source of.

Step 5 — Diagram Generator:

Draw the Boundary You Just Traced Remember the Notion clipboard bridge — renderer → preload → IPC → main process? Describe that chain (or paste in the modules you recovered) and use the Diagram Generator to turn it into a diagram. For an Electron or multi-process target this is the single most useful artifact of the whole exercise: it is how you explain to a teammate what happens, and it is how you spot the boundary you forgot. (There is a full walkthrough of this on the blog: How to Turn Code to Flowchart from AI.)

Step 6 — Regex Generator:

Extract Strings and Patterns at Scale Reverse engineering generates piles of text: extracted strings, log lines, protocol payloads, byte patterns. Describe what you are hunting for in plain English and let Regex Generator build the pattern, instead of hand-writing a regex you will debug for an hour.

A Complete Walkthrough: From I Want That Feature to Working Code

1.Name the question. How does this app compute X? Write it down; scope beats ambition. 2.Install the inspection layer. npx rea-agents setup, approve the config changes, restart your agent. Node.js 22.x/24.x/26+ required. 3.Let the agent choose the surface — JavaScript/Electron first if the app ships one, since it needs no native engine. 4.Collect evidence. Read the returned pseudocode, symbols, and call traces; ask follow-ups in the agent rather than starting over. 5.Paste the output into AI Powered Coding Assistant → Explain Code. Get the execution-order walkthrough. 6.Translate Code into your target language. 7.Build it. It will fail. That is expected. 8.Fix Code, then take the generated regression test and check it against the original — REA's own showcases compare reconstructed output against historical compiler output and original test cases, and you should do the same. 9.Review Code the finished version, then Diagram Generator it for documentation. Steps 5 through 9 all live inside the same four-step loop the site documents: choose your task, paste code or describe the task, select the model, generate the result — with session history, copy/download, and the option to ask for a revision instead of starting from scratch.

Ethics, Licensing, and the Limits You Must Respect

REA ships a disclaimer, and it is there for a reason. Understanding how a feature works so you can build your own version is a normal engineering activity. Redistributing someone's code, stripping licence notices, copying a proprietary implementation into a commercial product, or circumventing a protection measure is not, and no tool changes that. Also note the practical split: static inspection reads files without running anything, while runtime capture executes or interacts with the target using your user permissions — so check the relevant guide before you run anything.

The rule of thumb that has kept engineers out of trouble for decades still applies in the agent era: copy the idea, write your own code, and cite the technique.

FAQ

Can AI reverse engineer a native binary without Hopper, Ghidra, or IDA?

Not the deep native analysis. Static JavaScript and .NET inspection work with no native engine, but pseudocode and assembly from a compiled binary require a disassembler/provider behind the MCP server.

Does the analysis run in the cloud?

No. REA runs locally and returns findings — which is also why the results include limitations: it is working from the artifacts you gave it.

Is reverse engineering a closed-source app legal?

It depends on jurisdiction, the licence, and what you do with the output. Research and interoperability analysis is broadly treated differently from copying. Get proper advice for commercial use.

Do I need to know assembly?

You need to be able to read it enough to spot suspicious constants and boundary conditions. The Explain Code task in AI Powered Coding Assistant meaningfully lowers that bar, but it does not remove the need for judgement.

What genuinely cannot be done yet?

Anything requiring hardware-level access you do not have, server-side logic you cannot observe at all, or targets so heavily protected that the recovered structure is meaningless. AI shortens the reading time; it does not create evidence that was never there.

Summary - Can AI Reverse Engineer Anything?

No — but it can reverse engineer far more than most developers assume, and it can do it in an afternoon instead of a quarter. The winning combination is not one magic tool. It is an agent with local inspection tools to gather evidence, plus a coding assistant to explain that evidence, translate it, fix it, review it, and document it.

If you are starting today: pick a small feature you admire, install the inspection layer, and let the agent show you the evidence. Then bring the output here and finish the job — start a free session on AI Powered Coding Assistant Free and turn someone else's behaviour into your working code.