Article based on video by
An AI coding agent can inspect a website, desktop app, or binary—but only if it has the right tools and enough evidence to work from. Most guides skip the messy parts, so this walkthrough follows the complete REA GitHub workflow in Claude Code, from first installation to a practical implementation plan.
📺 Watch the Original Video
What REA GitHub Is and Why It Matters
REA GitHub is the home of REA, or Reverse Engineer Anything: a repository that combines an MCP server with practical workflow guidance for AI coding agents. Instead of handing you a polished app template, it helps agents inspect how existing software behaves and turn those observations into an implementation plan.[5]
REA is an agent-assisted reverse-engineering toolkit
Think of REA as a sous chef for an AI developer: it gathers the ingredients before anyone starts cooking. It can examine websites, Electron apps, desktop software, mobile packages, .NET assemblies, native binaries, JavaScript bundles, and runtime evidence, depending on the tools available on your machine.[5][8]
The output is usually a set of observations, evidence, structure, and suggested next steps. What surprised me here was the emphasis on investigation rather than magic—REA does not recover proprietary source code or recreate hidden internals perfectly.
How REA differs from a starter template or code generator
A starter repository gives you files to edit. REA gives an agent a way to ask better questions: What screens exist? Which events trigger navigation? What APIs are called? How does the application respond when something fails?
That distinction matters. You might use REA to study a website’s layout and network behavior, then build a separate implementation from your findings—not clone the original source.
What the MCP server adds to Claude Code
The Model Context Protocol (MCP) lets Claude Code call external tools and data sources through a standardized connection.[1] REA runs as a local MCP server, allowing compatible agents to request inspections instead of relying only on the files already in the coding workspace.
Setup can be guided with `npx rea-agents setup`; it adds the server and matching workflow instructions, backs up existing configuration, and requires an agent restart afterward.[3] In my experience, that restart is the step people skip first.
Which targets REA can analyze
REA supports browser investigations, JavaScript and Electron applications, .NET assemblies, native Mach-O, ELF, and PE binaries, Android packages, and other resources.[5][8] Results depend on the target, operating system, and installed tools.
For clean-room rebuilding, keep licenses, terms of service, privacy, and intellectual-property rights in view. Sound familiar? The safest workflow is to document observations and create an independent implementation rather than treating reverse engineering as a shortcut to someone else’s code.
Install REA and Connect It to Claude Code
REA connects coding agents to a local Model Context Protocol (MCP) server, giving Claude Code tools for inspecting websites, desktop apps, mobile interfaces, JavaScript bundles, assemblies, and runtime behavior. The setup is usually straightforward, but the small details matter—especially configuration backups and restarting Claude Code afterward.[3]
Prerequisites: Node.js, npm, and a working Claude Code installation
Before starting, make sure Node.js and npm are installed, your terminal is working, and Claude Code launches normally. You’ll also need permission to run local commands and a target you’re authorized to inspect.
Check the basics with:
“`bash
node –version
npm –version
claude –version
“`
I’d use a current Node.js LTS release rather than an old system version; outdated Node installations are one of the most common causes of setup failures.
Install REA with npx or npm
The simplest approach does not require a permanent install:
“`bash
npx rea-agents setup
“`
The prompts can differ by operating system and installed agents. Choose Claude Code when asked, review the proposed changes, and approve them. REA’s setup can register its MCP server and matching workflow instructions for Claude Code, Codex, Cursor, Gemini CLI, and other supported clients.[3]
If you prefer a global installation, use:
“`bash
npm install –global rea-agents
rea setup
“`
Back up configuration files before changing them
Before approving automatic edits, copy your existing Claude configuration files. This gives you an easy rollback if JSON becomes malformed or an agent setting changes unexpectedly.
For example:
“`bash
cp ~/.claude.json ~/.claude.json.backup
“`
Your actual file location may differ by platform or Claude Code version, so check the proposed path before copying it.
Manual MCP configuration when automatic setup fails
If automatic setup cannot find Claude Code, add a local stdio server entry manually. A typical configuration looks like this:
“`json
{
“mcpServers”: {
“rea”: {
“command”: “npx”,
“args”: [“-y”, “rea-agents@latest”, “mcp”]
}
}
}
“`
The important fields are `command` and `args`: together, they must launch REA’s MCP server. If `npx` is not on Claude Code’s PATH, replace it with the absolute executable path, or use the full path to the REA command.[7]
Restart and verify the connection
Fully quit and restart Claude Code after changing MCP settings. Stale sessions often make a correct installation look broken.
Then ask Claude Code to list its available REA tools, or run a harmless inspection against a permitted test target. If tools are missing, check Node versions, npm permissions, PATH settings, JSON syntax, executable paths, and whether another Claude Code session is still using the old configuration.
Use REA to Analyze a Real Target
REA works best when you give it a narrow question, not a vague command to “analyze the whole app.” It connects coding agents such as Claude Code, Codex, and Cursor to inspection tools for websites, desktop apps, mobile interfaces, Electron bundles, .NET assemblies, and native binaries.[1][3]
Start with a narrow research question
Begin with one feature or user journey: “How does checkout validate an address?” is far more useful than “Explain this product.” Your target brief should include the URL or artifact path, the feature to investigate, the expected output, and clear boundaries.
For example: “Inspect `/Applications/Example.app`, map its export flow, identify relevant files and events, and do not modify the original.” In my experience, this small amount of framing prevents hours of noisy results.
Analyze a website’s structure and behavior
For a website, ask REA to inspect routes, page structure, visual hierarchy, forms, responsive states, JavaScript behavior, API calls, and navigation. Then compare the page before and after one action—such as submitting a form—to identify the state transition and the component responsible.
That approach is like giving a GPS one destination instead of asking it to map an entire country. You get a clearer implementation plan and evidence you can validate.
Inspect desktop and Electron applications
First determine whether the application is native, Electron-based, or hybrid. That choice changes the investigation path: Electron apps usually expose JavaScript bundles, resources, windows, menus, event handlers, and renderer-to-main-process communication.
For .NET assemblies, native binaries, Android packages, and similar artifacts, use bounded searches for symbols, strings, resources, dependencies, and configuration. REA is designed to trace relevant code through MCP rather than make you guess from a directory full of files.[2][4]
Map mobile screens and interaction flows
Record each screen, gesture, dialog, permission request, keyboard behavior, loading state, and platform-specific navigation path. A useful output might describe the sequence from launch to account creation, including what appears when the network is slow.
Combine static and dynamic analysis
Static analysis examines packaged files without running the application. Dynamic analysis observes behavior while it runs. Comparing both is where most tutorials get it right: static evidence suggests where a feature lives, while runtime changes show what actually executes.
Avoid indiscriminate scanning. REA can run locally as an MCP server, and setup can be performed with `npx rea-agents setup`; after configuration, restart the coding agent so it discovers the server.[7][10] Narrow searches are faster, easier to explain, and much simpler to reproduce.
Turn Observations into an Evidence-Based Implementation Plan
Reverse engineering only becomes useful when observations turn into buildable decisions. REA connects coding agents to inspection tools through MCP, returning findings with evidence and limitations instead of asking the agent to guess.[1]
Ask what the agent observed and how it knows
Start with questions such as: Which component owns this behavior? What route triggered it? What changed in state? Which API request, storage entry, screenshot, trace, extracted code, log, network observation, or binary-analysis result supports that conclusion?
Ask the agent to label each claim confirmed, likely, or unverified. This small habit prevents a plausible explanation from quietly becoming “the architecture.” In my experience, that is where most reverse-engineering plans go wrong.
Separate facts, hypotheses, and unknowns
Require three explicit buckets: observed behavior, inferred behavior, and unanswered questions. Also distinguish what the application does from implementation details that cannot be confirmed externally—for example, whether a transition uses Redux, Zustand, or a private event bus.
Then request an architecture and data-flow report covering user flows, UI states, component boundaries, routes, state transitions, API contracts, storage, dependencies, error handling, edge cases, and open questions. REA is designed to preserve evidence and limitations during local analysis, which makes this report more than a polished guess.[2]
Convert findings into implementation tasks
Ask for a feature inventory, followed by a prioritized list of behaviors to reproduce. Turn that into milestones, tickets, technical decisions, acceptance criteria, and test cases; include at least one concrete test for every confirmed state or transition.
A useful report might identify 12 behaviors, but only five may be essential to the first milestone. Treat the inventory like a GPS that recalculates: new evidence should change the route.
Plan a clean-room recreation
Build new code, assets, and architecture based on observed behavior—not copied proprietary source, protected assets, or private implementation details. The goal is comparable functionality, not an unauthorized duplicate.
Use this reusable prompt with Claude Code:
> Investigate the target before writing code. Produce an evidence-backed reverse-engineering report. For every important claim, cite screenshots, traces, extracted code, logs, network observations, or binary-analysis results. Label each claim confirmed, likely, or unverified. Cover user flows, UI states, routes, component boundaries, state transitions, API contracts, storage, dependencies, error handling, edge cases, and open questions. Separate observed behavior from unconfirmed implementation details. Create a feature inventory, prioritize behaviors to reproduce, then convert the findings into milestones, tickets, acceptance criteria, test cases, and technical decisions. Do not copy proprietary source or protected materials; propose a clean-room implementation using new code, assets, and architecture. Stop and ask follow-up questions where evidence is insufficient.
Build, Test, and Troubleshoot the Recreation
Create the new project from the implementation plan
Start with the smallest end-to-end slice: launch the recreation, show its primary screen, perform the core interaction, reach the resulting state, and handle one realistic error path. Keep the codebase independent from the original, and label each decision as either observed behavior or a deliberate design choice.
REA can connect coding agents to inspection workflows through MCP, while setup adds both the server and matching instructions to supported agents.[1][2] In practice, I treat the implementation plan like a blueprint—not a photocopy—because the goal is comparable behavior, not copied source code.
Implement the highest-value user flow first
Build the path users depend on most before polishing secondary screens. For a website, that might mean loading a page, submitting a form, seeing a response, and recovering from a failed request; for a desktop app, it could be opening a document, changing a setting, and saving it.
Test responsive layouts, keyboard and pointer input, permissions, loading and empty states, unsupported formats, and failures. A flow that works only with a mouse on a wide screen is not finished; it is a happy-path demo.
Compare the recreation with observed behavior
Use screenshots, scripted interactions, runtime traces, and network or file observations as comparison points. Check concrete details: route changes, focus behavior, timing, error messages, data persistence, and what happens when an input is missing.
I’ve found that side-by-side comparison catches more than visual polish alone. Test at least two viewport sizes and one failure case, then record the difference instead of relying on memory.
Use REA again when results disagree
When behavior differs, return to REA with a focused question: “What happens after this permission is denied?” is far more useful than asking for another broad analysis. Static inspection can suggest a hypothesis, but runtime traces can confirm whether the application actually follows it.
Troubleshoot MCP and analysis failures
For target-specific failures, check inaccessible URLs, missing permissions, unsupported formats, obfuscated bundles, incomplete packages, and unavailable runtime hooks. For agent problems, inspect MCP registration, process startup output, configuration syntax, environment variables, and whether a restart is required; REA’s setup process backs up configuration before changing it.[1][3]
A repeatable workflow is: define scope, inspect, collect evidence, report, plan, implement, compare, and refine. That loop keeps the recreation grounded in evidence instead of guesswork.
Frequently Asked Questions
What is REA GitHub and what can it analyze?
REA, or Reverse Engineer Anything, is an MCP server and set of workflows that lets coding agents inspect software without its source code. It can analyze websites, JavaScript and Electron apps, .NET assemblies, native binaries, and runtime behavior—for example, mapping an Electron app’s modules, IPC boundaries, imports, and source maps.
How do I install REA and connect it to Claude Code?
In my experience, the quickest route is to have Node.js and npm installed, then run `npx rea-agents setup` and select Claude Code. REA backs up configuration files, installs the MCP entry and workflow instructions, and you should restart Claude Code afterward; use `npx rea-agents@latest setup` when you specifically want the newest release.
How do I configure REA as an MCP server manually?
What I’ve found is that a manual setup only needs a local MCP entry that launches REA through npm, such as `”command”: “npx”` with arguments `[“-y”, “rea-agents@latest”, “mcp”]`. Add that entry to the client’s MCP configuration, back up the file first, validate the JSON, and restart the client so it discovers the server.
Can REA reverse engineer a website or Electron application?
Yes—REA can inspect a live website and report page structure, scripts, network observations, and requested screenshots, while Electron analysis can recover modules, imports, routes, IPC relationships, and native add-on connections. For example, point it at an extracted app directory or ASAR with `npx -y rea-agents@latest analyze-javascript-application /absolute/path/to/app –json`.
How do I turn REA’s analysis into a clean-room implementation plan?
If you’ve ever tried rebuilding software from observations alone, the cleanest approach is to separate evidence from assumptions: list each user-visible behavior, supporting observation, edge case, and unresolved limitation. Then ask the agent to convert that inventory into independent requirements, public interfaces, test cases, and an implementation sequence—reproducing behavior without copying proprietary source code or assets.
📚 Related Articles
Start with one permitted feature, connect REA to Claude Code, and document the evidence before writing the first line of replacement code.
Subscribe to Fix AI Tools for weekly AI & tech insights.
Onur
AI Content Strategist & Tech Writer
Covers AI, machine learning, and enterprise technology trends.