Learn from real apps with REA

You know what you want your software to do. What you've rarely been able to see is how a real team turned that kind of want into something that works. That gap, between a requirement and how the software is actually put together, is one of the hardest problems in building anything, and it's why so much vibe-coded software looks right and falls apart soon after launch.

REA (Reverse Engineer Anything) closes a big piece of that gap. It's an open-source tool, now past 250,000 stars on GitHub, that plugs into a coding agent like Claude Code or Codex and lets it inspect software on your computer and explain how it works: native apps, JavaScript and Electron apps, .NET programs and websites. The analysis runs locally, and each conclusion comes with its evidence and limits. The point isn't cloning anyone; it's learning from people who already did the hard thinking.

An X-ray and an accelerator

If you build software, REA is an accelerator: you can ask exactly how a feature works and get the mechanism. If you don't, it's an X-ray: a way to see the decisions inside the software you use every day, and to ask questions about them, even if you've never written a line of code.

Take the authenticator app on your phone: six digits and a timer. REA's published investigation of Aegis, an Android authenticator, follows the code that makes them: an account key combined with the current time, grouped into 30-second windows. The same key in the same window gives the same code. You go from six mysterious digits to a relationship you can reason about, and the same works for almost anything you've wondered about.

Find the requirements you didn't know you had

Say you want a tool for your own research: collect passages from documents, keep notes beside them, find everything again when you write. You know the work. But that doesn't tell you how it should be represented in software. Is a quote just text, or an object with its source attached? When you copy it elsewhere, what travels with it? If you edit the copy, does the original change? Each answer pushes you toward different technical choices, and often you only discover them by seeing how a working system does it.

Copy and paste in Notion. REA's investigation shows that copying a block puts plain text and HTML on the clipboard, while richer structured block data is kept locally, with an identifier in the HTML that reconnects them when you paste. "Make sure copy and paste works" was never a full requirement: does the quote arrive, the link to its source, the note? Those details are what make software feel finished.
The calculator's % button. In the Windows calculator, 200 + 10% gives 220, but 200 × 10% gives 20. The operation before it decides what the button means. Ask an AI builder for "a percentage button" and you haven't specified the real behaviour.

The same applies to bigger features. When you say "send a reminder", when does the clock start? When you say "approve a request", which permissions change? When you say "undo", how much work should disappear? Studying a real implementation gets you past the headline of a feature to the decisions that make it useful. It also surfaces hidden costs: if richer data depends on a local copy, what happens when that's gone, or when the content moves to another computer?

From investigation to your own build

The aim isn't to copy an app's screens; that reproduces where a number appears without how it's produced. A community developer investigated QuickBooks Desktop for Mac with REA, focusing on the behaviour where the meaning lives: inventory arithmetic, reconciliation, balances and cash-basis reporting. They then built their own accounting app, Ledger Reborn, in Python and SQLite, which saves invoices, records payments, tracks inventory and produces reports.

Recording a payment sounds simple until you ask: does it cover the whole invoice? Can one payment cover several? What remains outstanding, and what should the report show? Someone who handles invoices every day knows which situations are common and which mistakes create work. REA gives that knowledge a way to reach the technical decisions underneath. You don't need the original's architecture or stack; you need the behaviour that matters to you, for software that may serve just you or a small group.

Developers can zoom further in. REA's look at a browser version of Chrome's dinosaur game shows why it keeps getting faster: speed starts at 6 and rises by a thousandth on each update without a collision, up to 13. Its DX-Ball case study traces how a brick's horizontal position becomes the left-right pan of its sound inside the compiled game. Narrow questions like these give you a rule you can reuse and tune.

Using it well

Tell it how deep to go. Ask for a complete explanation of an application and you'll get a mountain of material that doesn't help your next decision. Give the agent a reason: "I want to understand this behaviour; follow the relevant part."
Start from the work. If you don't code, describe what your software should support and ask the agent to identify familiar components and explain them, with diagrams if that helps. If you do, describe your constraints and where you're stuck, then ask for the mechanism and an implementation.
Use it to learn. Have it explain a system, then explain it back in your own words. It's a patient teacher for software at a depth that used to be hard to reach.

Use it responsibly

Install from official sources only. The project points to github.com/morluto/rea, rea.tools and the rea-agents npm package. Look-alike repositories and downloadable zips have already appeared; a copied README doesn't make a download safe.
Check the licence. Many software licences restrict reverse engineering. Learning how something works is different from redistributing it; build your own implementation.
It only sees what's on your computer. Server-side code stays private, and trying to reach it would be hacking. Don't.

Coding agents could do some of this before, with careful prompting and patience. REA makes it the default. There's an enormous amount of problem-solving inside the apps you already use, and now there's a way to study it. Pick something you've always wondered about and start asking questions.