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 (66)
I think a lot more this topic after my first comment. Result this is lead a whole software industry crysis. - I hope not.
But at the end maybe raise a bunch of well crafted software a much more specialized target smaller group taste. Make a lot smaller company.
More craft, less factory — that’s the hopeful version, and I think it’s the likely one. Cheap building makes the niche viable, so software gets personal again: many small makers serving specific taste, instead of giants serving no one in particular.
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.
The “builder actually uses it themselves” test is probably the best survival predictor anyone’s offered, because it quietly solves the maintenance problem the whole thread keeps circling — someone scratching their own itch still ships fixes in year three, while someone chasing a viral launch is gone the week the attention fades. Dogfooding is the cheapest sustainability signal there is.
Honest answer: no, I haven’t run them, and I deliberately didn’t hang the piece on whether the clones are good — that’s the trap. You’re almost certainly right that most of the seven are buggy messes; the creator said so himself. But the argument doesn’t rest on them being good. AI collapsed the cost of building, not finishing, so a wave of impressive-but-unusable alphas is exactly what you’d predict. The point isn’t “Photoshop is dead,” it’s “the thing that made Photoshop unassailable just got cheap to challenge.”
That is a great way to frame it. The maintenance problem is where most clones die. Building the first version is the easy part. Fixing bugs, handling edge cases, and keeping it running for years is the hard part. Someone who actually uses the tool has a reason to keep fixing it. Someone who just wanted to go viral does not.
AI actually widens that gap. It makes the first version nearly free, so launches flood in, but it does nothing for the motivation to sustain — more clones, higher abandonment, simultaneously. Build cost fell to zero; maintenance cost didn’t move; motivation is the only thing bridging them. So “does the builder use it themselves?” stops being a nice signal and becomes the whole forecast.
Dogfooding is the right word for it. I have noticed the same thing with my own projects. The ones I actually use get better over time because I feel the pain every day. The ones I build for other people sit and rot. The tool you use every day is the tool you fix. The tool you demo once is the tool you abandon.
And this is not a self promo I just wanna show you an example in which I have vibe coded a calculator to save myself from marketing gimmicks lootlens.antideploy.com/ only such tools you should be fixing or investing you more time on.
I’ll take a look when I can manage the time!
“The tool you use every day is the tool you fix. The tool you demo once is the tool you abandon.” — that’s the whole maintenance problem in two lines, and it matches my own graveyard exactly: the projects I feel the daily pain of get quietly better, the ones I built for a hypothetical someone else rot untouched. Pain is the renewable fuel; a demo burns once.
Sure thing thanks
Maybe try selling them cold pitches or reach out on linkedin or stuff like that. And if you are good with people pitch them IRL
😊
Briliant question, and analysis. I think those Adobe and Microsoft clones ( Word for example ) got so many works, even contributors to not wipe out so easy. My personal story on a certain point connected to Flash, then adobe bye it |> R.I.P. Flash. Without a proper vector based animation program ... I so miss. I also works many years as graphic designer, with lot of PS using also. After I change direction to coding, PS cost was too high to keep it up, so I changed to Krita. The real problem is that program cost you totally right the agents is downgrade the monopoly.
I was also put in the table this question ( not so direct )
Singularity News
plus I also solve my personal problem ( maybe affect many of us ) with a fork
TS + |> to hack JS
There’s a lot of real history in this — the Flash story especially lands, because it’s the dark mirror of the clone wave: a tool people loved, bought by a giant, then killed, leaving a gap that still isn’t properly filled years later. That’s the monopoly problem from the other direction — not just high prices, but the power to simply end a thing people depended on, with no recourse. Your path from graphic designer to coder, dropping PS for Krita when the cost stopped making sense, is exactly the pressure the piece is about: people don’t leave because the alternative is better, they leave because the squeeze finally outweighs the switching pain. And you’re right that agents downgrading the monopoly is the real story under the clone hype. I’ll check out your post soon . Thanks for bringing the lived version; the Flash angle alone is worth its own piece.
AI may make building software cheaper, but creating something people can trust, maintain, and rely on is a completely different challenge. The real disruption might not be replacing paid apps overnight, but forcing established companies to compete on value rather than lock-in.
Here’s the bigger question: If AI lets anyone clone almost any app, what should users pay for in the future—the software itself, or the trust, security, support, and continuous improvements behind it?
That closing question is the one the whole piece was circling toward: if the software itself becomes near-free to replicate, then what you’re actually paying for was never the features — it’s the trust, the security, the support inbox someone answers, the promise that it’ll still work and still be maintained in three years. And you’ve named the real disruption precisely: not paid apps vanishing overnight, but giants being forced to compete on value instead of lock-in, because lock-in was the thing that let them stop competing. My honest answer to your question: users will pay for the guarantee, not the artifact — “this will keep working, and someone stands behind it” is the one thing a weekend clone can’t ship, and it’s exactly what becomes scarce when building gets cheap.
Exactly. When building software becomes cheap, trust and long-term reliability become the real differentiators. People aren’t just paying for features; they’re paying for peace of mind, accountability, and the confidence that someone will be there when things break.
yeah!
Honestly, I don't think Big Tech is sweating this at all. Sure, AI makes it easy to spin up an alpha clone in a weekend, but the open-source graveyard is full of projects that started with big hype and died the second maintenance got boring. Giants know that building a rough MVP is easy, while keeping a complex app secure and updated for years takes a real team. They will probably just wait out the hype cycle.
You’re probably right about today — “wait out the hype cycle” is rational, and the graveyard math is on their side. Where I’d push: they’re not sweating this wave, and shouldn’t. The thing to watch isn’t whether these clones survive — it’s whether the cost of each new attempt keeps falling. Giants survived past waves because mounting a credible challenge stayed expensive. If that stops being true, “wait it out” stops working, because there’s always another attempt.
The majority of the vibe coders out there has no idea on what they are truly doing. I loved your blog post but the point I reached on the below statement, which made me confusing and it defeated the purpose all together 🤣
Fair catch. The tension is real: most vibe coders don’t know what they’re doing — and the giants can still lose. Both hold, because the giants don’t need a competent clone to lose; they need “build your own” to stop being impossible. Possibility erodes monopoly pricing even when 99% of the attempts are junk. The threat is the floodgate, not any one flood.
Small data point from the other side of this: building stopped being the hard part for me a while ago, and it didn't make selling any easier.
I had an agent ship a $5-or-pay-what-you-want ebook abroad. 14 people took it free before anyone paid; the first paid copy came after I set a $5 minimum. Before that I'd spent $41 on X ads: 16,569 impressions, 70 clicks, 0 paid orders. Cheap to build, and still zero.
So my guess at "what survives" is less about the code and more about whatever makes a stranger trust you enough to pay: a track record, a specific person's specific problem solved, a support inbox someone answers. A clone can copy Photoshop's features. It can't copy the twenty years of people already knowing it works.
That ad data is brutal and clarifying — thousands of impressions, zero paid orders, and the first sale only came when you removed the free option. The build cost went to zero and moved you nowhere on the thing that actually gated revenue: trust. Features are clonable; twenty years of people knowing it works isn’t. That’s the real moat, earned at human speed no matter how fast the code gets written.
Small correction to my own story: I didn't remove the free option, I set a $5 floor on pay-what-you-want. Same lesson though. The 14 who took it free were real people, they just weren't buyers yet.
The part I keep chewing on is "human speed." I tried to rush it with ads and got impressions, not trust. Slow threads like this one haven't sold anything either, but at least people talk back, which the $41 never got me.
Fair correction — a $5 floor, not removing free, though the lesson holds either way. And “impressions, not trust” is the whole thing in three words: ads buy attention, which is the cheap part; trust was never for sale at $41, because it doesn’t move at ad speed. A thread like this hasn’t sold anything either, but people talk back — and that two-way exchange is the actual raw material trust is built from, slowly, which an impression never is. You didn’t fail to buy trust; you just found out it’s not the kind of thing you can buy.
Yeah, that lines up with what I measured. My replies on X got 0 to 2 impressions each, while threads here actually turned into back-and-forth like this one. Slow, but it's the only part that felt real.
That tracks — a real back-and-forth with a few people beats a thousand impressions that nobody actually read, because conversation is the part that was never for sale.
Yeah. The annoying part is that impressions are the number the dashboard shows you first, so it takes a while to stop checking it. A reply from someone who actually ran the thing tells me more than a few hundred views ever did.
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 part I'd watch isn't a clone's feature list but whether it opens the files people already have. Most people can't switch editors because years of work sit in PSDs with adjustment layers and smart objects, and a clone that imports a flattened version hasn't touched the lock-in at all. It's also the least vibe-codable part: the published spec only covers some of it, and the rest is a long tail of files real users produced in odd ways. If the giants feel pressure anywhere, I'd expect it where a clone round-trips those files faithfully, not where it has the most tools.
File round-tripping is the sharpest moat-test here, because lock-in runs on your trapped files, not features. A clone that imports a flattened PSD gave you a viewer, not an exit. And it’s the least vibe-codable part — the spec covers the happy path, the lock-in lives in the long tail of files real users made in weird ways. An AI clones visible behavior from a screenshot; it can’t clone format quirks it’s never seen in the wild. That narrow, grueling work is the real pressure point.
The point about the moat being the cost of building, not the idea itself, is the one that sticks. Once that cost collapses, a clone can look impressive and still fail the last stretch that makes software usable day after day.
That matches how we see client work. The easy part is getting a first version that resembles a known product. The hard part is writing down the one problem the first release must solve, with checks that prove it, and keeping everything else off the list. Clones usually skip that discipline because the goal is resemblance rather than a clear finish line.
I would be interested in which failures you have seen most often once a clone meets real users. Is it reliability and data, or simply that nobody cares enough to keep using it?
From what I’ve seen it’s mostly the second, and it’s upstream of the first. Reliability-and-data failures are real, but usually fatal only because nobody cared enough to still be around when they surfaced. A tool someone genuinely depends on gets its data bugs fixed because the maintainer feels them daily; a tool built for resemblance gets abandoned before the edge cases even appear. Indifference is the primary cause of death; the technical debt is just what it leaves behind.
Some comments may only be visible to logged-in visitors. Sign in to view all comments.