The best a clone can do is tie
Perplexity just shipped a skill called /reverse-engineer. Point Perplexity Computer at an app, and it "inspects how the app works without its source code, then builds a working version." The launch thread shows off five clones, and the headline one is Figma: layers, auto-layout, multiplayer, the works.
Sound audacious?
Well, they're not the only ones. Since September 30, a studio called ArtCraft has put up 13 open-source clones of Photoshop, Premiere, Word, Excel, Pro Tools, AutoCAD, Figma and more, and they've collected about 172,000 GitHub stars between them. Meanwhile, thousands of people are playing Switch and PS5 games natively on PC, because agents rebuilt them from the games' compiled code.
Back in May, I wrote that the future of SaaS is cloneable. I also wrote, "Asking AI to implement a SaaS clone shouldn't be, 'Hey, reverse engineer this for me.'" Five months later, "Hey, reverse engineer this for me" is a product feature.
So if an agent can rebuild your features in a few weeks, what are customers paying you for? I don't think the answer is lawyers. Copying software is cheap now. Making it good isn't.
Every clone needs a judge
Agents can grind on a problem for weeks when something tells them, every single time, whether they got it right. Give an agent a check it can't argue with, and even a small model goes a long way.
Clones come with that check built in:
- Decompiling has the strictest judge there is. A rebuilt function either compiles to the same bytes as the original or it doesn't. One developer's agents rebuilt 99% of the functions in Call of Duty: Modern Warfare 2, 83% of them byte for byte, over about five months. By the end, he was running 14 small Luna agents and 2 Opus agents.
- Rewriting can use the original project's own test suite. Cloudflare rebuilt 94% of the Next.js API that way, for about $1,100 in tokens. (This only works if that test suite is publicly available.)
- Rebuilding from the outside uses the original app's behavior as the answer key. ArtCraft's agent rules tell its agents to "observe behaviour by using the app," then build to match from public specs.
In every one of these loops, the judge is the original, so the best possible score is "identical." The best a clone can do is tie.
The loop can't reward "better," because better doesn't match. It pulls toward the original's mistakes as faithfully as its good ideas. And even a tie is a long way off. PhotoCraft's own parity tracker rates it about 45% ready for real work against Photoshop, and estimates 2,300 to 4,100 more Opus agent-hours to reach full parity. Every time Adobe ships an update, the target moves.
Is any of this legal?
Mostly, depending on how you did it. This isn't legal advice, but here's the short version, with more in the FAQ at the end:
- What an app does is mostly free to rebuild. Copyright covers code, art and text. It doesn't cover ideas, workflows or methods of operation, and courts have treated menu layouts as unprotectable since Lotus v. Borland in 1995.
- The terms you clicked usually aren't. This is the big one. For instance, Figma's Acceptable Use Policy says you can't use Figma "to compete with Figma, or copy any ideas, features, functions, or graphics of the Services." When Figma sued Motiff, it claimed breach of contract as well as copyright, and the 2025 settlement made Motiff stop selling its editor everywhere except mainland China. Perplexity's Figma demo runs straight into that. Its skill is built on REA, an open-source tool that opens the target app in a browser and records what it sees: page structure, scripts, network traffic and screenshots. The launch video shows the agent doing exactly that inside Figma. Using Figma to copy Figma's features is what the policy forbids, so the demo carries the same kind of contract exposure Motiff had.
- Locks are the bright line. Breaking DRM or a license check is its own violation under the DMCA, even if you copy nothing.
- Open-sourcing the clone doesn't help. If you weren't allowed to build it, giving it away for free doesn't fix that.
Say you did everything by the book, though. What did you actually end up with?
What a copy gets you
Every app is a pile of decisions. Some hold the product up. Some were accidents. Some are compromises the team would undo tomorrow if they could. From the outside, they all look the same, so a clone copies all of them.
You get the decisions without the reasons. You get the features users love and the ones they complain about, in the same proportions. And when you need to change something, nobody on your team knows which choices are load-bearing, because nobody on your team made them.
There's a human cost, too. Somebody spent years learning why that panel belongs there and when to break the rule. An agent that copies every behavior exactly takes the answer without the person who'd know when to change it.
Artists have spent three years saying this about image models. Now, we have the same complaint about a different craft.
The original keeps moving
A clone is a snapshot. The team that made the original keeps making decisions, and the next version ships whether or not anyone copied the last one.
Some companies would rather defend themselves with contracts. In 1982, a Wisconsin professor named David DeWitt published database benchmarks where Oracle came out slow. Larry Ellison reportedly called DeWitt's department chair and asked for him to be fired. When that didn't work, Oracle added a clause to its license banning published benchmarks, and most database vendors followed. It's called the DeWitt clause, after him.
A benchmark here is just a speed test: run the same work on two products, time them and compare. You can run all the tests you want. You just can't tell anyone the results without permission. Oracle's license still says you may not "disclose results of any Program benchmark tests without Oracle's prior consent," in the same sentence that bans reverse engineering.
| What you do with a speed test | Allowed under a DeWitt clause? |
|---|---|
Run it yourself to choose a database | Yes |
Publish the results in a paper or blog post | Only with the vendor's permission |
Post a chart of your numbers on social media | Only with the vendor's permission |
In 2021, Databricks dropped its DeWitt clause and asked other vendors to do the same. That's what a confident company sounds like: go ahead, compare us.
All that said, copying does sometimes win, when the copier has more reach than the original. Instagram Stories launched in 2016 and passed Snapchat's daily users within a year. Microsoft bundled Teams into Office until European regulators stepped in: Slack complained in 2020, and in 2025 Microsoft committed to selling its suites without Teams.
But most of today's agent clones are the other kind: small teams without distribution, shipping a snapshot that starts aging the day it ships.
What good looks like now
So what should all this agent power go toward? I'd start with what people are trying to get done, before looking at anyone's app. Someone recording a Loom wants a teammate to see a problem without booking a meeting. Someone in Figma wants their design built the way they pictured it. Those jobs outlast any one app's screens, so aim at them instead.
Some things are worth copying as they are. Blocks, slash menus, comments and the shortcuts everyone already knows are shared patterns that users expect, and software has always borrowed them from itself. Nobody pays royalties on Ctrl+Z.
File formats are the other place where an exact copy is the goal. When someone brings a Figma file or a PowerPoint deck into your app, or takes their work back out, it has to look the way it did before. For imports into Agent-Native Design and Slides, we gave agents a pixel-diff loop: render the original, render our import, highlight every pixel that differs, and keep fixing whatever's highlighted.
Everywhere else, scoring against the original can only get you a tie, so score against the job. Pick a real task and measure how well people get it done: how long a teammate takes to understand a bug from a recording, say, or how many edits it takes to turn an outline into a deck someone would present. Those numbers can go past where the incumbent sits, so "better" becomes a score the loop can actually reach.
Then spend what you saved on things the incumbent doesn't do. Here are two from Agent-Native:
- Clips is our open-source Loom alternative. Its browser extension records console errors and failed network requests while you record, so a bug report shows up with the evidence attached. Loom leaves that evidence behind in DevTools, so a loop scored against Loom would never have asked for it.
- Design is our open-source Figma alternative, but instead of static mockups on a canvas, it builds a working HTML prototype from your own design system. A Figma clone gets graded on how closely its canvas matches Figma's. The job is getting the design built, and handing off working code beats handing off a rectangle.
When you do study someone else's product, keep a list of every place you chose to differ, and why. Product teams have a framework for this sorting: the Kano model, from quality researcher Noriaki Kano in the 1980s. It splits features into basics, which nobody notices until they're missing; performance features, where more is better; and delighters, which nobody asked for but people love once they have them. Agents are great at basics, because the original is a perfect answer key for those. The delighters come from your list.
Once you ship, anyone can copy what you built. The list is harder. A clone can see what you changed, but not why, what you tried and threw out, or where the list points next. As long as that reasoning stays with your team, it's where your taste shows up, and it's the part a clone can't take.
Charge for what can't be cloned
If agents can rebuild features, features stop being something you can charge for. What's left is everything a clone can't take with it: the team, the next version, keeping it running, and the help people get when it breaks.
That's the bet we're making with our Agent-Native suite of software. It's MIT-licensed, so you can fork all of it today: Content, Mail, Calendar, Slides, Clips, Design and the framework underneath. Build locally and host it anywhere, or build and deploy online with Builder.io. We'd rather charge for things that make sense, like running it for you, than for features anyone could clone in a couple of days.
Copying is the whole point of Agent-Native. Every app in it is meant to be forked and reshaped to fit how you work, and the framework underneath is there so you can build the apps we haven't. If someone took Agent-Native and closed it off, they'd be selling the one version nobody can change, right when everything else is getting easier to change.
MIT does let someone do that. History suggests it doesn't stick when the original stays open. In 2014, some of Node.js's core contributors disagreed with how Joyent, the company that ran Node at the time, was handling the project. So they forked Node.js into their own project, io.js. Once Node moved to an open foundation, the two merged back together in 2015. Forks come home when upstream is the best place to work.
The harder version of the question is hosting. After AWS started selling hosted Elasticsearch, Elastic changed its license in 2021, and AWS forked the code into OpenSearch. HashiCorp's 2023 license change produced OpenTofu. Redis's 2024 change produced Valkey, and Redis lost most of its outside contributors: before the change, 12 non-employees made 54% of its commits, and a year later no non-employee had made more than five. Elastic and Redis have both added an open-source license back. Closing up didn't stop the copies. It stopped the contributions.
So, here's how we think about it. If someone hosts Agent-Native better than we do, people get a better product, and we have to keep up. We'd rather compete on that than on a license.
The contributions are the part I'm most excited about. When someone puts their own taste and their own agent's tokens into a feature and sends it back, everyone gets that feature. Open source turns everyone's AI spending into shared improvements.
Don't we want to make good things?
We're living in a world now where, even if something is closed source, someone can clone it anyway. So we'd rather make the cloning easy and free, and get your ideas back.
Whether you're copying or being copied, the same thing wins: a team that keeps deciding well. An agent can match what you've already built. It can't match what you'll decide next.
So go ahead and fork us. Then show us something better, and send it back so we all can use it.
FAQ
Is it legal to reverse engineer software?
Often, depending on what you copy and how you get it. In the US, rebuilding an app's behavior from the outside is usually fine under copyright, and courts have treated disassembling code to understand how it works as fair use (Sega v. Accolade). But most license agreements forbid reverse engineering, and US courts usually enforce those terms, so the bigger risk is breach of contract. Breaking DRM or a license check is illegal on its own. In the EU, you keep a right to observe, study and test software you're licensed to use, and a contract can't take it away.
Can I clone an app if I open-source the clone?
Open-sourcing doesn't make a clone legal or illegal. If the clone copies someone's code, art or text, sharing it for free is still infringement, and if you broke the original's terms to build it, that claim is still there. What changes is the process. A copyright owner can send GitHub a takedown notice, while a contract claim means suing the people who agreed to the terms.
What's a clean room?
A way to build a compatible product without copying the original. One team studies the original and writes a spec. A second team, which never sees the original, builds from that spec. Phoenix used it to rebuild IBM's PC BIOS in the 1980s, and projects like Wine and ReactOS follow similar rules today. Some agent projects now split the work between separate agents the same way, but no court has decided whether an AI clean room counts.
