01What REA DeepSeek Harness Is and How It Works
REA DeepSeek harness is a setup where you plug REA, short for Reverse Engineer Anything, into DeepSeek harness so DeepSeek can look inside apps and explain how they work. It then uses what it finds to rebuild the idea as your own tool.
In this episode, Julian Goldie pointed this setup at three apps on his Mac. For each one, DeepSeek opened it up, showed the evidence of how it works, and rebuilt the idea as a business tool.
The three builds were:
- An agent control deck.
- A lead flow reactor.
- His own website, rebuilt from scratch.
The setup has two parts. REA gives the agent the tools to look inside software. DeepSeek harness is the brain that decides what to do with those tools and then writes the new build.
Together, they turn a question like how does this app split up work into a clear answer with proof, and then into something you can use.
02What REA (Reverse Engineer Anything) Can Do
REA is an open source tool on GitHub, and it is MIT licensed. It gives your AI agent one set of tools for reverse engineering, so the agent does not need a different tool for every type of software.
It can work with:
- Native programs.
- JavaScript and Electron desktop apps.
- .NET apps.
- Android apps.
- Websites.
Everything runs on your own machine. You are not sending the app off to some other service to be picked apart.
The part Julian likes most is that every answer comes with the evidence behind it. When REA says an app works a certain way, it shows where that came from. That matters, because AI agents can sound sure of themselves even when they are guessing.
With REA, you can check each claim.
This also changes what you can learn from software. Instead of only seeing what an app looks like from the outside, you can see how its parts fit together. That is what lets DeepSeek rebuild the idea behind an app, not just copy its screen.
03Why DeepSeek Harness Is the Brain for REA
DeepSeek harness is DeepSeek's own agent app. It is open source too, and MIT licensed. The key detail is that everything inside it is a plugin.
So REA just slots in as one more plugin.
For the model, Julian runs DeepSeek V4.1 Flash. He picked it for two reasons:
- It is fast.
- It can look at screenshots.
The screenshot part matters more than it sounds. When DeepSeek builds something, it can check its own work by looking at what it made. That helps it spot problems on the page without you pointing them out.
Put together, the harness handles the planning and building, and REA handles looking inside the software. The model reads the evidence REA collects, then uses it to design the new version.
If you already use DeepSeek harness, this means you do not need a new app. You add REA, restart, and your existing agent gains the ability to study software and explain how it works. Julian sums it up simply: a few commands and DeepSeek can now look inside software.
04How to Set Up REA in DeepSeek Harness
Here is the setup Julian walks through in this episode. It takes three commands plus a few clicks.
- Open your terminal.
- Install REA. Run the REA install command with npx.
- Check the install. Run REA's check command and look for the DeepSeek harness line. You want it marked healthy.
- Restart DeepSeek harness.
- Open a new session. Pick your project folder.
- Pick your model. Julian uses DeepSeek V4.1 Flash.
There is one common snag. If DeepSeek tells you your account quota is used up, you have another route:
- Go to Settings.
- Open Models.
- Add OpenRouter with your key.
- Pick DeepSeek V4.1 Flash from that list.
That is exactly what Julian did for the builds in this episode. Once the harness line shows healthy and your model is picked, you can start asking DeepSeek to use REA on an app.
A good first test is a small app you own. Ask DeepSeek to use REA, write down the evidence, and explain how one feature works before you ask it to build anything.
05Build One: An Agent Control Deck
The first target was an open source desktop app that runs several AI agents side by side. Julian asked DeepSeek to use REA to find out how it does that, then build his own version.
DeepSeek loaded the reverse engineering skill, unpacked the app and mapped it. Then it hit a limit. Two bundles were too big to parse.
So it raised its own memory limit, narrowed the search to the app's own code, and kept going.
Then came the honest part. Its report said exactly which conclusions came from the code and which parts it could not read. That is the evidence habit doing its job.
It found three key pieces:
- An agent manager at the heart of the app.
- One adapter for each kind of agent.
- How each conversation tracks its status.
With that map, DeepSeek built an agent control deck with six live agents for a dental practice called Bright Smile Dental. The idea came from studying how the original app works, but the result is a new tool shaped around a real business.
06Build Two: A Lead Flow Reactor
The second target was another open source app. You give it a job, and it splits that job across a team of worker agents. Julian asked DeepSeek to use REA to find out how it breaks a request into tasks and hands them out, write down the evidence, then build a lead flow reactor for his dental practice.
This is where REA earned its place. The desktop app turned out to be just the front. The real task splitting lived in a Python backend shipped inside the app.
DeepSeek would never have guessed that on its own. REA found it.
So DeepSeek rebuilt that pattern for leads. New leads fly into the reactor, and each one gets split into four tasks:
- Qualify.
- Reply.
- Book.
- Follow up.
The tasks shoot out to four worker lanes. When an appointment gets booked, the whole screen celebrates. You can also add a lead by hand, and it goes straight through the same flow.
The lesson here is that the look of an app can hide where the real work happens. Evidence beats guessing.
07Build Three: Rebuilding a Website With REA
For the third build, Julian used REA's website analysis on his own site, juliangoldie.com. He asked it to map the sections, fonts, scripts and buttons, then rebuild the site as an elegant premium version.
This time REA did something different. It launched a real browser, loaded the site, and captured:
- The page structure.
- The fonts.
- The scripts.
- Where every button leads.
It mapped 15 sections. Then DeepSeek rebuilt the site using his real sections and words. The new version has big serif headlines that fade in as you scroll and soft warm light.
Every service, every result and real reviews are laid out cleanly.
It was not perfect the first time. The first version copied a banner Julian did not want. So he asked for a revision right in the same chat, and DeepSeek fixed it in one pass.
Note that Julian owns this website. That matters, and it ties into the rules he shares for using REA the right way, which come next.
08Tips and Rules for Using REA DeepSeek Harness
Julian shares what he learned from these three builds:
- Always ask for an evidence file. It keeps DeepSeek honest, and you can check every claim.
- Focus on the app's own code on big apps. Tell it to skip the bundled libraries, so it does not get stuck on huge files.
- Only look inside software you own, or open source software you are allowed to study. Then build your own version with your own name and design.
- Describe the look in detail. Spell out colors, fonts and motion. That is the difference between a plain dashboard and something people want to use.
This setup is for business owners and builders who want to learn from good software and turn those ideas into their own tools. The dental examples show how a pattern from one app, like splitting a job across workers, can become a lead system for a real business.
Julian shares the exact prompts for all three builds, the setup checklist, the evidence checklist and the design brief inside the AI Profit Boardroom.