Skip to main content
MindStudio
Pricing
BlogAbout
My Workspace

Lean REA: How an 8KB Skill File Beat a 207-Tool MCP Server

An 8KB skill file beat the REA reverse-engineering MCP server by 38% on speed and 35% on cost in a 36-run head-to-head benchmark.

Edited by Luis Chavez-Mattos, Director of Product RSS
Lean REA: How an 8KB Skill File Beat a 207-Tool MCP Server

What is Lean REA and why does it matter?

Lean REA is an 8 kilobyte skill file built as a lightweight alternative to REA (Reverse Engineer Anything), a popular GitHub project that ships a 207-tool MCP server for reverse-engineering tasks. In a 36-run benchmark comparing the two inside Claude Code, Lean REA finished all tasks 38% faster and 35% cheaper than REA, while matching it almost exactly on accuracy (74 correct answers out of 75, versus REA’s 75 out of 75). The result argues that for many agent tasks, a short list of the right shell commands beats a large tool server built on top of the same underlying utilities.

TL;DR

  • A creator built Lean REA, an 8KB skill file, after arguing in an earlier video that REA’s 207-tool MCP server was unnecessary overhead for reverse-engineering work.
  • Across 36 runs covering four reverse-engineering tasks, Lean REA was 38% faster, 35% cheaper, and used 56% fewer agent turns and 60% fewer tokens than REA, with nearly identical accuracy.
  • REA’s own npm package runs about 25 megabytes with 72KB of skill docs, while Lean REA condenses the same workflows into a single 8KB file with no MCP server.
  • The biggest speed gaps showed up on Electron and Go binary tasks, where REA needed multiple tool calls and sometimes dumped huge outputs (one run returned 140 megabytes of JSON) that the agent then had to parse in extra turns.
  • When Claude Code’s tool search feature is disabled, loading REA’s full tool list into context burned roughly 400,000 tokens just to process a single “reply with okay” message, costing about $160.
  • The baseline model with no skill and no MCP server already performed close to REA’s accuracy, meaning the real efficiency gain comes from replacing REA specifically, not from adding any skill at all.
  • Lean REA is open source and installable through the skills CLI, supporting Claude Code, Cursor, Gemini CLI, Codex, and other agent environments.

Everyone else built a construction worker.
We built the contractor.

🦺
CODING AGENT
Types the code you tell it to.
One file at a time.
🧠
CONTRACTOR · REMY
Runs the entire build.
UI, API, database, deploy.

How does Lean REA actually work?

REA functions as a wrapper. For an Electron app, it calls the ASAR packaging tool. For a Mac binary, it shells out to otool and nm. For Go binaries, it reads the same build metadata that go version -m already exposes. For Android, it leans on jadx and apktool. In other words, REA’s 207 tools mostly repackage utilities that already exist on a developer’s machine, wrapped in an MCP server and CLI layer.

Lean REA strips that layer out entirely. There’s no MCP server and no additional tool registration. The agent uses its normal shell access and calls the underlying utilities directly.

The skill file itself has three parts:

  1. A short list of ground rules. Work on a copy of the target file, identify the file type before acting, avoid dumping large minified files into context, and search within a file rather than reading it whole. It also tells the model to batch multiple small checks into a single shell call to cut down on round trips.
  2. A router table. This maps target types (Electron apps, minified web bundles, Mac/Linux/Windows binaries, Go, Rust, .NET, Android APKs, Flutter, WASM, SQLite, packet captures, firmware, websites) to the fastest known command for each.
  3. “First moves.” These are ready-to-run commands that chain several checks into one call. For a Mac binary, for example, a single command retrieves linked libraries, exports, imports, strings, and function lists in one pass instead of several separate tool invocations.

The file also preserves specific tricks pulled from REA’s own source code, such as how to read Electron fuses, locate Go build info inside a binary, or find a Flutter snapshot hash. It closes with a simple evidence-labeling rule: every claim the model makes gets tagged as seen, inferred, or unknown, rather than letting the model assert something is absent just because it wasn’t found.

How was the benchmark structured?

The creator ran everything through Claude Code in headless mode using a Sonnet 4.5-class model, testing three setups: no skill and no MCP server (plain model with normal tools), Lean REA, and full REA (MCP server plus official REA skill docs).

Four tasks were used, each run three times per setup for 36 total runs:

  • Electron app tracing: find the native function, controlling class, and IPC channels behind a specific feature in a real desktop Electron app.
  • Native add-on analysis: on a small Mac binary from that same app, list exports, explain a permission check, and explain a single-instance lock mechanism.
  • Go binary inspection: using the GitHub CLI binary, identify the Go version and the versions of two dependencies.
  • Disassembly task: the hardest case, requiring the model to read disassembly of the same native add-on to find an exact socket file path, the wire protocol, and how the app verifies connecting clients.

Each answer was checked against a hand-built answer key.

What were the actual results?

Every team builds with AI.
Nothing gets lost.

On total time across all 36 runs, Lean REA finished in 388 seconds, the no-skill baseline took 479 seconds, and REA took 627 seconds. On cost, Lean REA totaled $2.17, the baseline $2.21, and REA $3.36. On agent turns, Lean REA used 55, the baseline 81, and REA 124.

Measured against REA directly, Lean REA was 38% faster, 35% cheaper, used 56% fewer turns, and used 60% fewer tokens. Accuracy was nearly identical: REA scored 75 out of 75, Lean REA scored 74 out of 75. The single miss involved an app with two versions of the same IPC channel, where one Lean REA run named the older version.

The widest gaps appeared on the Electron and Go tasks. On the Electron task, Lean REA took about 35 seconds versus roughly 83 seconds for REA. On the Go task, Lean REA took about 12 seconds versus roughly 26 seconds for REA. The explanation is structural: Lean REA uses one direct command per target, while REA requires the model to first locate the right tool, call it, then parse a large result. In one REA run, the tool’s output was large enough that Claude Code saved it to a file, forcing extra turns just to open and read it.

Does REA actually hurt performance by loading too many tools?

This depends heavily on agent configuration. Claude Code includes a feature called tool search, which loads MCP tools on demand rather than all at once. With tool search enabled, REA adds only about 3,500 tokens of overhead, which is negligible.

But many agents load all available tools into context from the start. With tool search turned off, sending a single trivial message (“reply with okay”) consumed about 400,000 tokens when REA’s full 207-tool set was loaded, at a cost of roughly $160 for that one exchange. By comparison, the no-skill baseline used about 31,000 tokens for the same test (Claude Code’s standard system prompt), and Lean REA used around 34,000 tokens. In agent setups without selective tool loading, REA can consume most of the available context before the model even looks at the target file.

Is the plain model without any skill good enough?

Largely, yes. The no-skill baseline was already close to REA in accuracy and came in cheaper on raw dollar cost, though it ran slower and used more turns than Lean REA (19% slower, roughly 32% more turns). This matters for interpreting the benchmark correctly: the big efficiency win is Lean REA over REA specifically, not skill-based approaches over no skill at all. A capable model with ordinary shell access already handles most reverse-engineering groundwork; the skill mainly helps it get there faster and with fewer wasted calls.

A separate raw tool comparison reinforces the point. For Go binary metadata, REA’s CLI took about half a second versus 0.06 seconds for the plain go version command. For a Mac binary overview, REA took 3.3 seconds versus 0.04 seconds for direct commands. For the Electron app, REA initially failed with an integrity error and required an extra flag; once working, it took about 48 seconds and returned 140 megabytes of JSON, while extracting the ASAR archive and searching it with ripgrep took about 5 seconds and returned 24 kilobytes containing the answer.

What should builders take from this?

› Build a claims-review app for 400 adjusters.
already included:✓ HIPAA✓ access control✓ audit log✓ self-hosted
The enterprise platform for building software with AI.

The creator found and fixed two bugs in Lean REA while testing it, both worth noting for anyone building similar skill files. Ripgrep skips hidden folders by default, and many Electron apps store bundled code in a hidden “webpack” directory, so the skill now explicitly tells the model to use the -u flag. Separately, a shell marker using two equal signs broke under zsh’s special parsing rules and had to be quoted. Even a small, carefully written skill file needs real-world testing against actual targets.

The broader implication for agent builders is that tool count isn’t inherently valuable. A large MCP server wrapping existing system utilities can add latency, cost, and context bloat without improving accuracy, especially in agent environments that don’t support selective tool loading. A short, well-organized reference of direct commands, paired with a capable model, can match or beat a heavier tool server on tasks that ultimately reduce to running the right shell command at the right time.

Frequently Asked Questions

What is REA (Reverse Engineer Anything)?

REA is an open-source MCP server and CLI that gives AI agents 207 tools for reverse-engineering tasks across Electron apps, native binaries, Go, Rust, .NET, Android, and more. Internally, it mostly wraps existing utilities like otool, nm, jadx, and apktool rather than implementing new reverse-engineering logic.

How big is Lean REA compared to REA?

Lean REA is a single skill file of about 8 kilobytes. REA’s skill documentation alone runs about nine times larger (roughly 72KB), and its full npm package is around 25 megabytes.

Does Lean REA sacrifice accuracy for speed?

In the benchmark, no. REA scored 75 out of 75 correct answers across the 36 runs, while Lean REA scored 74 out of 75, a negligible gap given the small sample size of three runs per task.

Is REA still worth using?

It depends on the agent setup. If the agent supports selective tool loading (like Claude Code’s tool search), REA’s overhead is small. In agents that load all tools into context upfront, REA can consume a very large portion of available context and budget before any real work happens.

How do you install Lean REA?

It’s distributed through the skills CLI and supports Claude Code, Cursor, Gemini CLI, Codex, and other agent platforms. Installation is done via npx skills, which prompts for target agents, with flags available to apply it globally or skip prompts.

Editorial standards

Presented by MindStudio

No spam. Unsubscribe anytime.