Big Idea

The argument in one line.

A coding agent plus a reverse-engineering toolkit plus free fallback models on OpenRouter lets a non-programmer build working lookalikes of familiar apps at zero cost per token.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You want to try agentic app building but the token bills from a paid coding assistant are what's stopping you.
You're a non-developer who learns best by watching every click of a setup, including where API keys go and which commands to paste.
You're curious how a tool like REA lets an AI inspect desktop and Electron apps before it writes any code.

SKIP IF…

You need production-grade software; the video itself says the clones are not complete replacements and some features still need testing.
You already run a paid coding agent comfortably and only want deep technical detail on how REA analyzes binaries.

TL;DR

The full version, fast.

Instead of paying for a premium coding assistant, the video builds a free stack in three levels. Level one installs DeepSeek Harness as the AI developer and adds REA with one npx command, then verifies it with the doctor check. Level two connects OpenRouter as a custom provider and saves a preset that chains three free NVIDIA Nemotron models so one can take over when another hits a limit. Level three tests the stack by prompting it to build a Slack-style Metis Workspace and a ChatGPT-style app. Both work, with caveats about free-model limits.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 02:30

01 · Why clone apps, and the three-level plan

Android analogy, the credit problem with the earlier Claude Code workflow, and the roadmap of setup, connect and build.

02:30 – 04:33

02 · Set up DeepSeek Harness

Download the desktop app, create a DeepSeek API key, add it to Harness and pick a model and thinking effort.

04:33 – 07:24

03 · Install REA

Explains REA as a detective toolkit, runs the one-line npx setup for Harness, then verifies with the doctor command.

07:24 – 09:30

04 · Connect OpenRouter free models

09:30 – 12:48

05 · Create a free model fallback preset

Build an OpenRouter preset with three free NVIDIA Nemotron models and tools, then add its ID to Harness.

12:48 – 17:03

06 · Build a Slack clone

Prompt the agent to build Metis Workspace with channels, DMs, threads and file sharing, using Slack's public interface as reference.

17:03 – 21:22

07 · Build a ChatGPT clone

Same setup builds a chat app with saved history, web search, deep research, URL analysis and media options.

21:22 – 22:15

08 · Final results

Recap of the three levels, caveats that this is not a full replacement, and a call to action.

Atomic Insights

Lines worth screenshotting.

A coding agent that only guesses at how an app works produces something that looks right and breaks on the first click, so it needs a way to investigate the original first.
REA gives an AI agent a toolkit to inspect desktop, Electron and compiled apps, so it traces how features work instead of guessing.
Running the REA doctor command after install checks every tool and connection, and pasting any red error into the agent with 'fix this' is the non-technical repair path.
An OpenRouter preset is a saved bundle of models, so the coding app connects to one preset ID instead of one fragile model.
Chaining three free models in a preset means a rate limit on one model no longer stops a build halfway through.
Free models come with limits, so fallback configuration matters more than which single free model you pick.
Pasting a preset ID as the model ID in a custom provider is all it takes to route a coding agent through your fallback list.
Asking the agent to copy only a publicly visible interface with your own name and branding keeps a clone prompt on the safe side of imitation.
Detailed prompts that name layout, features and small details like spacing and button behavior are what make a generated clone usable.
The same setup produced two unrelated apps, a team chat and an AI chat client, which shows the value is the workflow rather than any single prompt.

Takeaway

Free AI app building depends on fallback, not one model

WHAT TO LEARN

A coding agent becomes useful on a zero budget when it can investigate real apps first and has a list of free models to fall back on.

02Set up DeepSeek Harness

A coding agent should be pointed at your computer with a model and thinking-effort setting chosen up front, because that choice drives both quality and cost on every later task.

03Install REA

Reverse-engineering tooling turns cloning from guesswork into investigation, so the agent traces how a feature works before it writes code that imitates it.
After any install, run the built-in health check and hand failures straight back to the agent with a plain 'fix this' rather than debugging by hand.

04Connect OpenRouter free models

Sign up for OpenRouter, skip the payment method, and add it as a custom provider using its base URL and your API key.
Test a new connection with a small real task, such as asking the agent to inspect a local file, before starting a large build.

05Create a free model fallback preset

Save three free models in one preset so the router moves to the next when one hits a limit, then use the preset ID as the model ID.
Enable only the preset tools you need, such as web search and date-time, and remember that fallback still depends on which free models are available.

06Build a Slack clone

Write clone prompts that name the layout, the working features and the small details like spacing, icons and button behavior, and use your own name and branding.
Reference only a product's publicly visible interface, and keep the prompt and resources somewhere you can paste them again.

07Build a ChatGPT clone

Treat the results as working prototypes: free models can build a usable chat app, but some features still need testing before you rely on them.

Glossary

Terms worth knowing.

DeepSeek Harness: A desktop app from DeepSeek that acts as a coding agent on your computer. You describe what you want in plain English and it writes files, fixes errors and assembles the project.
REA: Short for Reverse Engineer Anything, a toolkit that lets an AI agent open and analyze other software, including desktop, Electron and compiled apps, and trace how each feature works.
OpenRouter: A service that gives access to many AI models through one API key and one base URL, including a set of free models.
Preset: An OpenRouter saved configuration that bundles several models and tools under one ID, so a client can reference the whole setup as if it were a single model.
Model fallback: A configuration where the router tries the next model on the list when the current one is unavailable or hits a usage limit.
API key: A secret string that lets one app talk to a provider's AI service on your behalf. It should be kept private.
Hopper: An extra analysis tool installed alongside REA, described in the video as a magnifying glass for apps that are harder to read.

Resources

Things they pointed at.

02:40productDeepSeek Harness ↗

03:20linkDeepSeek Platform ↗

05:40toolREA (Reverse Engineer Anything) ↗

08:00productOpenRouter ↗

09:50linkOpenRouter Presets ↗

01:00linkMaitis setup guide and prompts ↗

05:30linkYou Can Clone Any App for FREE (REA + 9Router) ↗

Quotables

Lines you could clip.

00:30

“Google never needed Apple's code. They just understood how it worked and built their own.”

clean analogy that frames the whole video→ TikTok hook↗ Tweet quote

05:00

“Guessing is how you end up with something that looks right, but falls apart the moment you click a button.”

states the problem REA solves in one line→ IG reel cold open↗ Tweet quote

07:10

“Don't try to fix it yourself. Copy the error, paste it into Harness, and say, fix this.”

a practical non-technical troubleshooting rule→ newsletter pull-quote↗ Tweet quote

The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

When Apple launched the iPhone in 2007, Google was secretly building a phone with a tiny screen and a keyboard. They took one look at the iPhone, studied how it worked, and rebuilt their whole phone around a touchscreen. That became Android.

And today, it runs on most of the phones on the planet, maybe even the one in your hand. Google never needed Apple's code. They just understood how it worked and built their own.

But Google had thousands of engineers to do that. For people like you and me, the apps we use are still locked boxes. We can use them, but we can't see how they're built.

And every month, we pay again. So what if you didn't need a team of engineers? What if you could look inside any app and build your own version without paying anything?

Two weeks ago, I showed you how to clone any app with Cloud Code, REA, and Nine Router. It worked, but Cloud burned through the credits way too fast. So today, we're going to explore a free workflow with DeepSeq, REA, and OpenRouter, which lets you use powerful AI models at zero cost per token.

And to prove it works, we'll build free clones of two apps millions of people use every day. Drop your guess in the comments. And I've saved the biggest surprise for the end.

People already pay good money for apps like these, and I'll show you how to turn this into a service. We're doing this in three levels. In level one, we'll set up DeepSeek with REA.

In level two, we'll connect OpenRouter. And in level three, we'll build those two clones. And that's where things get insane.

But before we jump in, give me 30 seconds. If you're building with AI, the idea is never the hard part. The setup is.

One missed command and nothing works. That's exactly why I built Midas .ai. Every video I make turns into a step -by -step guide there, with the commands, prompts, and links in order, ready to copy and paste.

The REA setup I showed you two weeks ago is already up, and today's DeepSeq and OpenRouter workflow goes right next to it. When you're ready to explore more, there are 760 -plus AI tools waiting, and you can filter for the free ones. And the best part?

It's completely free. So if you're building along with me today, the link's in the description.

And if you're new here, hit subscribe, because we break down stuff like this every day. Alright, let's open the first box.

Before we build anything, we need someone to do the actual building. And we're not hiring a developer, we're using one. It's called DeepSeek Harness.

Think of it as a developer that lives on your computer. You tell it in plain English what you want, and it writes the code, fixes the errors, and puts everything together for you. So, let's get it set up!

Search for DeepSeek on Google, open the official website, and click on Harness Desktop. Download the app for your computer. I'm on a Mac, so I'll just drag it into applications and open it.

When it opens, you'll see two options. Sign in and add a PI key. We're going with the API key.

Now, an API key sounds technical, but it's really just a password that lets the app talk to DeepSeek's brain. To get one, search for DeepSeek API, open the DeepSeek platform, and sign in with Google. Go to API Keys, click Create New API Key, give it a name, and copy it.

Come back to Harness, click Add API Key, paste it in, and continue. And just like that, we're inside. Let's take a quick look around.

In Settings, you'll find the appearance, the models, built -in plugins, and agent presets. we'll use the standard preset for this project. Now, here's the part that matters.

Harness lets you pick which AI model does the thinking. We've got DeepSeek v4 .1 Flash and DeepSeek v4 Pro, and you can even choose how hard it thinks. For our project, we're setting the thinking effort to high.

But remember, our whole goal is to do this without paying for expensive AI. So in the next level, we're plugging in OpenRouter, which gives us models we can use for free. Hold that thought.

Because right now, there's a bigger problem. Our developer is smart, but if we just say, build me a copy of this app, it has no idea how the original actually works. It would be guessing.

And guessing is how you end up with something that looks right, but falls apart the moment you click a button. That's where REA comes in. REA stands for Reverse Engineer Anything.

Think of it as a detective's toolkit for software. On its own, it's just a box of tools sitting on a shelf. But plug it into your AI and the AI becomes the detective.

It can open up an app, study how it's built, and trace exactly how each feature works. Desktop apps, electron apps, even compiled programs. REA has a tool for each of them.

So instead of guessing, our developer actually investigates first and then builds. And REA isn't tied to one AI. It works with Claude Code, Gemini, CLI, Cursor, and a bunch of others.

Today, we're plugging it into DeepSeek Harness. By the way, if you want the full deep dive on REA, we've already made a complete video on it called, You Can Clone Any App for Free, REA Plus 9 Router, a Complete End -to -End Tutorial. The link is in the description.

Now, let's plug the toolkit into our developer. Search for REA on Google and open its GitHub page. Scroll down to the README, where you'll see its features, supported apps, and the install instructions.

Open your terminal and paste this one line. npx rea -agents at latest -setup -client -dsh. Hit enter.

That one line tells REA, set yourself up for deep -seek harness. You'll see a short plan of what it's about to install. In our case, that's the REA skill, the harness settings, and an extra analysis tool called Hopper.

Think of Hopper as a magnifying glass for apps that are harder to read. Type Y and let it run. Once it's done, we need to make sure everything actually works, and REA has its own health check for that.

They literally call it the doctor. NPX, REA -Agents, Doctor. The doctor checks every tool, every connection, and tells you if anything is missing.

You want it all green. And if something isn't green, here's the trick. Don't try to fix it yourself.

Copy the error, paste it into Harness, and say, fix this. That's how you do technical setups without being technical. Last step, restart DeepSeek Harness.

Just like your phone after an update, it loads its new tools when it starts up again. So, in plain English, here's what we've got so far. DeepSeek Harness is our developer, the one who writes the code.

REA is the detective's toolkit that lets it look inside other apps. And the doctor makes sure it's all connected. And if you've made it this far with your setup working, Quick favor, hit subscribe, because we break down tools like this every single day, and you don't wanna miss the next one.

But there's still one piece missing. Our developer needs a brain to think with, and we don't wanna pay for an expensive one. That's exactly what we're fixing next, and this is where the free AI models come in.

Level two, setting up OpenRouter. So now we've got our developer, DeepSeek Harness, and we've given it REA, the most important toolkit it needs to study other apps. But there's still one thing missing in this setup.

We need an AI model to actually power our developer. And we don't want to keep paying for every little task. That's where OpenRouter comes in.

Think of OpenRouter as a place where you can access different AI models through one connection. And the best part? Some of these models are free to use.

So let's connect it to our setup. First, open OpenRouter .ai, click Sign Up, and continue with Google. Select your account, complete the verification, and choose Individual.

Now, OpenRouter will give you an API key. Copy it and keep it safe, and don't share it with anyone. We'll need it in a second.

You'll also see an option to add a payment method, but since we're using free models, we'll skip that for now. And just like that, we're inside. Now let's head back to DeepSeq Harness.

Open Settings, go to Models, and add a custom provider. We'll call it OpenRouterFree. For the base URL, paste this.

Then add the API key we just copied. And there we go! Our developer can now connect to OpenRouter.

But before we move ahead, let's quickly check whether REA is working properly. Remember, we installed REA in Level 1, but we haven't actually tested it with our AI yet. So open a new chat, select open router slash free and paste this prompt now let's watch what happens deep seek starts checking the connection looks through the available tools and gives us a report it even opens a local system file to check whether rea can actually inspect something and it works perfectly Now, before moving forward, we need to pay attention to a few additional tools, including Hopper, but the main connection is working.

So, we've got our AI developer talking to REA, and both are connected through OpenRouter. Pretty cool, right? But there's one more thing I want to show you, and this is actually one of the most useful parts of this entire setup.

See, free AI models usually come with limits. Imagine you're halfway through building an app, and suddenly the model you're using reaches its limit. Now you have to switch to another model, reconnect everything, and figure out where you left off.

That's exactly what we want to avoid. So instead of relying on one model, we're going to create a small team of free models that can back each other up. And for that, we'll use Open Router's presets.

Think of a preset as a saved setup. We choose the models once, save everything together, and connect that setup to DeepSeq Harness. So head back to OpenRouter, open Presets, and click New Preset.

I'm going to name ours Free Models. And in the description, I'll write, Free AI Model Fallback for DeepSeq plus RIA. Now scroll down to Models and click Add Model.

First, we're adding NVIDIA Nemotron 3 Ultra, free. Next, NVIDIA Nemotron 3 .5 Super VL, free. And finally, NVIDIA Nemotron 3 .5 Lightning, free.

So now we've got three free AI models in one place. And here's why we're doing this. Think of it like having three people working on the same project.

If one person can't continue, another can step in. It's a similar idea here. With model fallback configured, if one model becomes unavailable or hits a supported usage limit, OpenRouter can try another model from our list.

That means we don't have to manually change our model settings every single time something goes wrong. Of course, this still depends on the available free models and their limits, but it makes the whole setup a lot more flexible. Now, scroll down to the Tools section.

Here, we'll enable Web Search, Date Time, Fusion, Advisor, and Subagent. Once that's done, click Save Preset. And OpenRouter gives us a preset ID, at preset slash free dash models.

Copy this, because we're going to connect it to DeepSeq Harness. Now head back to Harness, open Settings, and go to Models. Under our OpenRouter free provider, click Add Model.

Paste at preset slash free dash models into the Model ID field, give it the display name Free Models, and click Apply. And that's it! We've connected our custom model setup to DeepSeq Harness.

So now, instead of depending on just one AI model, our developer has a list of models it can use, with fallback options if one isn't available. And that's what makes this setup so useful. Now, let's quickly look at everything we've done so far.

We've set up DeepSeq Harness as our AI developer, connected REA to help it understand other apps, and added OpenRouter to power everything with free AI models. So now we've got our developer, the right tools, and the AI models, all without needing a paid subscription. And if you want to discover more free AI tools and workflows that can replace expensive ones, subscribe to Midas.

We're always testing them so you can get more done without spending money. Now comes the real test. Can this setup actually build something useful?

In level three, we're going to recreate the two apps I showed you earlier and see how close we can get. Let's put it to work. Now comes the most exciting part.

We've got everything connected, and it's finally time to see what this setup can actually build. And for our first challenge, we're going to recreate Slack. Now, if you haven't used Slack before, think of it as WhatsApp, but for work.

It helps teams communicate, create separate channels for different projects, share files, and keep everything organized in one place. Pretty useful when you're working with a team and don't want important messages getting lost between different conversations. So, here's what we're going to try.

We'll use the free AI models we just connected to build our own version of Slack. And not just something that looks similar. We want to actually send messages, create channels, and interact with the app.

Let's see how close we can get. First, open DeepSeq Harness and make sure our Open Router preset is selected. Now, in the chat box, we're going to give DeepSeek a detailed prompt explaining exactly what we want to build.

I'm calling our app Metis Workspace. We'll ask it to use Slack's publicly visible interface as a reference, but with our own name and branding. We want the familiar purple sidebar, different channels, direct messages, a messaging area, and a search bar.

And of course, working features like sending messages, creating channels, replying in threads, and sharing files. We'll also ask it to pay attention to the smaller details, like spacing, icons, and how the buttons respond when we click them. Because there's no point in building a beautiful app if we can't actually use it, right?

I'll leave the full prompt in the description so you can try it yourself. Now, let's see what happens. DeepSeek starts planning the project, creating a folder, and setting up all the files it needs.

Then, it begins putting together the sidebar, messaging area, and thread panel while connecting the different buttons and features. And the interesting part is that we're not writing any of this code ourselves. DeepSeq is handling the build based on our instructions.

After a little while, the build is complete. So, I ran it in the browser to see what we'd actually built. And look at this.

We've got the purple sidebar, different channels, direct messages, employee profiles, and a complete messaging interface. There are even message reactions and a separate panel for replies. It actually looks pretty close to what we wanted.

But here's the real test. Does it work? Let's find out.

First, let's click on the engineering channel. And there we go. The conversation changes and we can see messages from a different team.

Now let's create our own channel. Click Add Channels, type Quarterly Planning, and hit Create. And just like that, our new channel appears.

Let's send a message asking the team to share their priorities for next quarter. And there it is! Our message appears along with a sample reply.

We can even reply to a specific message by clicking the reply icon, which opens a separate thread on the right. Now let's try something else. I'll attach meeting -notes .txt, add a short message, and send it.

And there we go! The file appears in our conversation, and we can find it in the Files tab too. Moving on, we can also send direct messages to teammates, open a huddle for audio conversations, and search for channels like quarterly planning.

There's even a Notes tab where we can keep track of project priorities and next steps. So, quite a few features are working already! And just to make sure this wasn't a one -time thing, we ran another quick test.

We created another channel called Launch Planning, sent a message, attached a file, opened a thread, and tested Search and Huddle again. And the main interactions worked this time too. Now, of course, this isn't the complete Slack app.

It's a local version with sample conversations, not a fully connected messaging platform. But think about what we've just done. We started with a prompt, let DeepSeek handle the building process, and ended up with an app where we can actually interact with different features.

And we did it using the free AI models we connected earlier. Now, Slack was just our first challenge. We've got another app to recreate, and this one's going to be just as interesting.

So, let's see how our setup handles the next one. And this time, we're taking on something a little more challenging. We're going to build our own version of ChatGPT.

Now, we all know ChatGPT. You type a question, it gives you an answer, and you can have entire conversations with it. But there's a lot more happening behind that simple chat box.

So for our second challenge, we're going to see if DeepSeek can help us build something similar with a clean chat interface, conversation history, and all the features that make it easy to use. And the best part? We don't need to set everything up again.

We're using the same DeepSeek harness, REA, and open router setup that we used to build Slack. So let's get started. Just like we did earlier, open DeepSeq Harness and make sure our Open Router preset is selected.

Now, remember how we gave DeepSeq a detailed prompt to build our Slack workspace? We're going to do the same thing here, but this time we're asking it to build a ChatGPT -style application, clean chat interface, conversation history, a message box, and a responsive layout that works on different screen sizes. And I'll leave the complete prompt in the description so you can try it yourself.

Now, DeepSeq starts checking our workspace and REA connection, planning the project, and creating the necessary files. It builds the sidebar, message input, and chat interface without us having to write the code ourselves. Once it's ready, I ran it in the browser to see what we'd built.

And look at this! We've got our own ChatGPT -style app with a sidebar, a new chat button, conversation history, and a message box. But let's see what it can actually do.

First, let's ask it to explain photosynthesis in three simple steps. And here's where things get even more interesting. We can generate both images and videos using just a simple text prompt right inside our chatbot.

For example, let's ask it to create a peaceful sunset over a lake. And there we go! It generates the image based on our description.

We can even create videos the same way. Just describe what we want, and the AI can generate it for us. And the best part?

All our conversations are saved in the sidebar, so we can come back to them anytime. Now let's explore some more features. Click the plus icon beside the message box and you'll see quite a few options.

First is search the web, followed by deep research and analyze a URL. Then we've got create an image, create a video, add photos and files, my media, and upload images or videos. Let's quickly see what some of these actually do.

We'll start with Search the Web and paste a Wikipedia link about news television channels around the world. And look at that! It organizes the channels by region, including Asia, Europe, Africa, and the Americas, along with source links.

Now, using the same link, let's try Deep Research. This time, it gives us a more detailed report, looking at the reliability of the information and where there might be gaps. Next, let's try Analyze a URL.

And here, we get a shorter summary of the webpage, covering its main points and important details. So, instead of reading through the entire page, we can quickly understand what it's about. Now, moving on to media.

We can upload a reference image, add a prompt, and use the image creation option. There's also My Media, where our uploaded pictures and videos are organized in one place. And with Create a Video, we can enter a description of the video we want to make.

Now, the image and video creation options are part of our interface, although we haven't demonstrated completed AI -generated media here. But look at what we've built! We can have AI conversations, save our chat history, search the web, get research reports, summarize web pages, and manage media.

Of course, this isn't a complete replacement for ChatGPT, and some features still need further testing. But we started by building our own Slack workspace, and now we've created a ChatGPT -style app using the exact same setup. Two completely different applications, built without manually writing the code.

And that's what makes this workflow so interesting. You can start with an idea, turn it into something you can actually use, and keep improving it as you go. And that's all three levels!

We started with DeepSeq Harness, connected REA, and used OpenRouter to power everything with free AI models. Then we put the entire setup to the test by building our own versions of Slack and ChatGPT without writing the code ourselves or needing a paid AI subscription. And the best part?

You're not limited to these two apps. You can take an idea, describe what you want in plain English, and let these models help you turn it into something that actually works. And all the prompts and resources from today's video are in the description too.

Now, if you want to stop just hearing about AI and actually start building things with it, subscribe to Midas. We're constantly testing free AI tools, finding alternatives to expensive software, and sharing practical workflows that you can use yourself. And tell me in the comments, which app would you build first?

Thanks for watching and I'll see you in the next one!

The Hook

The bait, then the rug-pull.

Google rebuilt its phone after studying the iPhone, and the video asks what happens when anyone can do that to an app without a team of engineers. The promise is a free workflow that replaces a credit-hungry Claude Code setup.

Frameworks