Earlier this month, a developer in Atlanta got fed up with Adobe's cancellation fees. So he used Claude to clone the entire Adobe Creative Suite — seven apps, Photoshop through After Effects — rebuilt them from scratch in Rust, dumped them on GitHub for free, and declared "software is over."
He's not alone. Vibe-coded clones of paid apps are showing up everywhere right now: creative tools, CRMs that "drop Salesforce," all sorts of commercial software being reverse-engineered and reimplemented by individuals pointing AI agents at a problem that used to require a company.
Now, the honest part: most of these specific clones are rough. Early alpha, buggy, missing the brutal last 10% of polish that makes software actually usable. The Adobe-clone creator said so himself — "not anywhere close to ready." If you're waiting for a free Photoshop that fully replaces Photoshop, you'll be waiting a while.
But if you're only looking at whether any individual clone is good yet, you're watching the wrong thing. Something bigger just happened, and it's worth sitting with — because the wall that protected a handful of giants for twenty years just got a lot easier to climb. Let's talk about what actually survives here, and why it might be one of the better things to happen to software in a long time.
The moat was never the code. It was the cost of building it.
For decades, the giants' real protection wasn't genius. It was expense.
Building something like Photoshop, or Salesforce, or a polished premium SaaS, took armies of engineers, years of work, and tens of millions of dollars. That was the moat. Not that the software was impossible to conceive of — plenty of people knew exactly what a photo editor should do — but that actually building one at that level was out of reach for anyone without a war chest and a hiring pipeline.
That barrier is the thing that let them behave the way they did. It's why they could charge subscription rent forever, raise prices whenever, lock you into their file formats and ecosystems, make cancellation deliberately painful, and treat users as a captive audience rather than customers who could walk. Where were you going to go? Building your own was impossible. GIMP existed, and the fact that "the free alternative" was a punchline for twenty years tells you everything about how secure that moat was.
AI didn't make the clones good. Let's be clear about that. What it did was make them cheap and fast — and that's the variable that actually mattered, because cheap-and-fast is exactly the barrier the whole monopoly structure was built on. One person with an AI agent can now attempt, in weeks, what used to need a funded team and years. The clone doesn't have to be finished to matter. The wall just has to become climbable, and it did.
What actually survives (because it isn't the clones)
Let me be straight, because it's the honest center of this: most of these clones will die. They'll stall in alpha, or the maintainer will lose interest, or they'll never close the last-10% gap that separates "impressive demo" from "thing I trust with my work." Free clone graveyards are a real thing, and AI makes it easier to start a project, not to finish and maintain one.
So the clones themselves, mostly, won't survive. Here's what does, permanently:
The giants can no longer assume they're the only option. For twenty years, "build your own" was not a sentence anyone finished. Now it is — credibly, cheaply, repeatedly. And you don't actually need the clone to be perfect for this to change everything. You need it to be possible. A monopoly's power comes from the absence of alternatives; the moment a credible alternative becomes cheap to mount, the monopoly has to start behaving like it has competition, whether or not any single competitor wins. Possibility is the product here, not polish.
That shift doesn't expire when the clones do. The cost wall fell, and it is not going back up.
Why this is genuinely good — and not just satisfying to say
It would be easy to make this purely about schadenfreude. I want to make the real argument instead, because it's stronger: this is good for reasons that have nothing to do with anyone's feelings about Big Tech.
Monopoly pricing dies when "build your own" becomes thinkable. You don't even need people to actually build the alternative — you need the giants to know they could. That alone caps what they can charge and how badly they can treat you, because the escape hatch is finally real. Prices, terms, and lock-in all have to get more honest when the door isn't locked anymore. Users win, directly.
Leverage returns to the small side for the first time in a generation. For two decades the relationship was entirely one-directional: accept the subscription, accept the price hike, tolerate the slow enshittification, or leave — to nothing. There was no "or else." Now there's a credible "or else," and leverage you can't negotiate from is the whole game. That's new, and it's healthy.
Innovation decentralizes. When building serious software required armies, only the well-funded could do it, which meant software got built to serve shareholders and quarterly targets. When it requires one motivated person and an AI, a thousand people can try — and some of them will build things the giants never would have, because they're scratching their own itch instead of optimizing a funnel. Not all of it will be good. But it'll be varied, and variety is where the genuinely new things come from.
And the companies most exposed are the ones who earned it. Notice why that developer built the Adobe clones: cancellation fees. Resentment. The feeling of being squeezed. The giants most vulnerable to this are precisely the ones who leaned hardest on their moat — aggressive pricing, hostile lock-in, treating loyal users like a billing relationship. The companies that actually treated people well have the least to fear. That's not revenge. That's the market finally doing the thing it's supposed to do.
The part that's hard to say politely
There's an irony here that's worth naming plainly, because it's real and it matters.
The giants pushed AI harder than anyone. They built it, embedded it in everything, sold it as the inevitable future — and, crucially, many of them cited AI-driven efficiency while laying off thousands of their own engineers. The message to workers was unmistakable: AI makes your expertise cheap, which makes you replaceable.
And now that same AI is making their moats cheap. The barrier that made them untouchable — the sheer cost of building software this good — is the exact thing AI is dissolving. The tool they wielded to cut their labor costs is the tool eroding the walls that let them charge rent.
This isn't childish "haha, suffer." It's something more structural, and harder to argue with: you cannot spend years telling the entire world that AI makes expertise cheap and replaceable, and then act shocked when AI makes your expertise — your product, your moat, your pricing power — cheap and replaceable too. The disruption they aimed at their own workforce turned around and pointed back at them. If you live by the AI-efficiency argument, you don't get to be surprised when you're disrupted by it. The symmetry is just honest.
The role AI is actually playing here
Strip away the drama and AI's specific role in all this is clear: it's the great equalizer.
It collapsed the one variable — build cost — that was holding the entire monopoly structure upright. For the first time, the ability to build serious, ambitious software isn't gated behind a company's balance sheet. It's in the hands of individuals. That's a genuine redistribution of a capability that was concentrated for decades, and it happened fast.
Now, the honest double-edge: the same AI that lets a solo dev clone Adobe also helps Adobe defend itself. The giants have more compute, more data, more distribution, more lawyers. AI arms both sides. But — and this is the whole point — it arms the small side far more, in relative terms, because the giants were already powerful and the little guy had essentially nothing. Handing a new weapon to someone who already has an army changes little; handing the same weapon to someone who had a stick changes everything. The uplift is asymmetric, and it favors the underdog. That asymmetry is why this is disruptive instead of just incremental.
Let's not kid ourselves, though
If I only told you the optimistic half, you'd be right not to trust me, so here's the honest counterweight.
The legal fights are coming, and they'll be ugly. "Clean-room reimplementation" — functional replication without copying code — is a real and defensible concept, but trade dress, trademarks, and the exact line between "inspired by" and "copy of" are not settled, and the giants have the lawyers to make that line expensive to approach. Some of these clones will get sued into oblivion regardless of their technical merits.
And "free clone" is not automatically a win for anyone. Software nobody maintains becomes a security liability. A clone without support, updates, and a community is a trap you walk into the day its single maintainer gets bored. The open-source graveyard is full of "free alternatives" that were genuinely better for about eight months. AI lowered the cost of starting; it did almost nothing for the cost of sustaining, which is where most of these die.
None of that undoes the core shift. But anyone selling you "software is free now, the giants are finished" is selling you the same overconfidence from the other direction. The wall fell. The giants will adapt, litigate, and survive. It's the uncontested part of their power that's gone.
What actually survives
So, back to the question in the title. What survives this wave of clones?
Not most of the clones. They'll do what early, unmaintained, one-person software usually does.
What survives is the end of an era — the one where a handful of companies could build an unbreakable wall out of engineering cost, sit behind it charging rent forever, and treat both users and workers as disposable, because there was genuinely nowhere else to go. AI knocked a hole in that wall. The giants aren't finished; they'll adapt and they'll endure. But they will never again have the uncontested dominance they had, because "build your own" stopped being impossible, and a threat that's cheap to mount is a threat that never fully goes away.
And for an industry that spent the last few years telling its own people they were replaceable by AI, there's a fitting symmetry in watching that same AI make monopoly itself a little more replaceable too.
That's not the end of software. It's a shift in who gets to make it — away from the few with the war chests, toward the many with an idea and an AI agent. Most of them will fail. That's fine. The point was never that everyone wins. The point is that, for the first time in a long time, the giants can lose. And a world where the giants can lose is a healthier one than the one we had.
Honest questions, and I want the real answers, not the comfortable ones: is AI collapsing the cost of cloning software actually good — the end of monopoly rent and lock-in — or does it just leave us a graveyard of abandoned clones and a decade of lawsuits? And the uncomfortable one: after years of "AI will replace you" pointed at engineers, is there genuine justice in AI coming for the giants' moats — or does it just feel good to say? I genuinely go back and forth.
Context & sources: this piece is anchored in the early-October 2026 release of ArtCraft — Atlanta developer Brandon Thomas's suite of seven open-source, AI-assisted "clean-room" reimplementations of Adobe's creative apps (Photocraft, Vectorcraft, Filmcraft, Lightcraft, Printcraft, Effectcraft, Designcraft), built with Claude Opus 5.5 in Rust and widely covered (Gizmodo, PetaPixel, KDnuggets, Phoronix, and others). The creator has described the apps as early alpha and "not anywhere close to ready." The broader "SaaSpocalypse" framing — the idea that AI-collapsed build costs threaten subscription software — and related clone projects (REA and others) are drawn from the same October 2026 reporting. Specifics are current-as-of-writing and moving fast; treat the trend as the story rather than any single clone's readiness.
Top comments (6)
The cost of building a clone may be collapsing, but the cost of earning user trust hasn't changed nearly as much. A working demo can reproduce the visible features, while the harder work sits in edge cases, data portability, reliable upgrades, security fixes, and years of compatibility. I think this shifts the competitive advantage from who can build the most features to who can sustain a dependable product with the least friction for users. AI makes it easier to challenge established software, but long-term maintenance and a clear path for users to leave or migrate their data may be what separates a credible alternative from another abandoned repository.
you’ve put your finger on the asymmetry the hype skips: AI collapsed the cost of building, but did almost nothing to the cost of sustaining, and those were always two different problems. A demo reproduces the visible 90%; trust is earned in the invisible 10% — the edge cases, the data portability, the security fix shipped at 2am, the upgrade that doesn’t break your decade-old files. That part is still slow, unglamorous human work, and no model shortcuts it.
So you’re right that the competitive axis rotates: from “who ships the most features” (now cheap, now commoditized) to “who sustains a dependable product with the least friction.” That actually raises the value of the boring stuff — maintenance, migration paths, a clean way to leave with your data — because it’s the one moat AI didn’t dissolve. The clone that survives won’t be the one that looked most like Photoshop on day one; it’ll be the one still safe to depend on in year three. Which is a more honest definition of “what survives” than mine, and it points at the same place from the maintenance side.
That “year three” test is a useful way to judge these products. I’d add one more signal: how safely a user can update, roll back, or leave the product without losing data or disrupting their workflow. Those lifecycle paths rarely show up in a launch demo, but they determine whether a clone becomes something people can depend on. AI may keep lowering the cost of creating alternatives; the harder challenge is making change predictable for the people already using them.
The reversibility test — can you update, roll back, or leave without losing your work — is the sharpest “year three” signal yet, precisely because none of it shows up in a launch demo, which is exactly why it separates dependable software from a pretty alpha. Making change predictable for existing users is the real discipline, and it’s the opposite of what vibe-coding optimizes for. AI keeps lowering the cost of the first version; the thing it doesn’t touch is the promise that version two won’t break you.
The sustainability question is the right one. I have seen a bunch of vibe-coded clones launch and disappear within weeks. The ones that survive are the ones where the builder actually uses the tool themselves and keeps iterating. The Adobe clone story is wild but I would bet most of those seven apps are buggy messes. Curious if you actually tried any of them.
First prompt: "Oh my God, this is magic." 60 billion tokens and 3 weeks of real data and real use cases later: the solution finally becomes useful.