A four-person team says it used AI to reverse-engineer Adobe’s most important tools and give the results away. Whether or not ArtCraft ever threatens Adobe, it raises a question the whole software industry now has to answer
For decades, creative professionals have lived under the thumb of a single company. Adobe’s Creative Suite, later rebranded as Creative Cloud, became the default toolkit for illustrators, photographers, designers, and video editors. The shift to a cloud subscription model brought high recurring fees, constant connectivity requirements, and a feeling among many users that they were renting their own tools. Competitors came and went. Few made a dent.
Then came ArtCraft.
A suite built in the image of Adobe
ArtCraft is a free, open-source suite of creative apps built by a four-person team, and its lineup will look familiar. Where Adobe has Photoshop, ArtCraft has PhotoCraft, pitched as an image editor you already know how to use. Where Adobe has Lightroom, ArtCraft has LightCraft, which promises no account, no cloud, no telemetry, and no subscription.
According to co-founder Michael Caffrey, as reported here, the project began when the team used Claude 5.5 to reverse-engineer seven of Adobe’s top tools. The results worked better than expected, so they decided to open source them. Caffrey frames it partly as a matter of principle: the tech industry has relied on open source for decades, models are now trained on open-source code, and so, in his words, there is a certain cosmic karma in open source biting back.
The apps are in active development, with some tools at the “early alpha” stage, so professionals are probably stuck with Adobe for now. The suite includes plenty of AI features, though they are optional. And because the project is largely vibe-coded, some observers worry about polish and stability. One Reddit commenter described it as impressive but noted that AI makes it easy to build prototypes quickly, and prototypes are not necessarily polished, stable products. Others simply want out of Adobe’s ecosystem, whatever is under the hood.
Whether ArtCraft matures into a real alternative is almost beside the point. What matters is what it demonstrates: a very small team, with AI assistance, can now produce credible imitations of software that once took thousands of engineers decades to build.
Why this is bigger than one project
ArtCraft is a single example of a broader shift. Two things are happening at once:
- Small teams can replicate large products quickly. Functionality that once required enormous organizations can be approximated in weeks.
- Ordinary people can build their own software. Users with little or no programming background can now create tools tailored precisely to their needs, with no vendor, no license, and no monthly fee.
Together, these raise an uncomfortable question for the industry. If anyone can build a clone of expensive software, what is left to sell? And what happens to the people whose job is building software in the first place?
The honest answer is that the consequences differ sharply depending on who you are. There are three groups worth considering separately: the big software companies, professional programmers, and the growing population of people who program without being programmers.
1. Big software companies: the moat moves
The first thing the clone era erodes is the value of simply having a lot of features. For years, a large part of a product like Photoshop’s defensibility came from the sheer effort required to rebuild it. When that effort shrinks dramatically, any company whose advantage rests on “we wrote a great deal of code” has a problem. Subscription models are exposed too: if a free alternative is good enough, willingness to pay for baseline functionality falls, especially among casual users and hobbyists.
But code was never the whole product. Several things are far harder to copy:
- Reliability. Decades of fixes for edge cases, giant files, odd hardware, and unusual workflows are not visible in a demo. A clone that looks complete can fall apart under professional load.
- Ecosystems and standards. Plugins, shared file formats, templates, tutorials, and industry habits create strong lock-in. A freelancer will not switch tools if their clients, collaborators, and vendors all use the original.
- Data, models, and infrastructure. High-quality AI features, cloud collaboration, and properly licensed content (fonts, stock assets, training data) depend on resources a small team cannot easily replicate.
- Support, accountability, and compliance. Enterprises pay for someone to call, for contractual guarantees, and for certifications.
- Legal firepower. Reverse engineering and copying of behavior or interfaces can trigger disputes over copyright and other intellectual property. Large companies are well placed to defend their position, which may deter the most blatant clones.
The likely result is uneven pressure. The low and middle of the market, including casual users, students, and prosumers, is most vulnerable. Intensive professional use is better protected, at least until clones mature.
How might incumbents respond? Expect more flexible pricing, more generous free tiers, and a shift in competition from individual features toward integration, services, proprietary data, and brand trust. Some may use open source strategically, releasing parts of their own stack to commoditize the layers their competitors depend on. The companies most at risk are those with thin products and thin networks; the best protected are those with deep ecosystems and enterprise customers locked in by contract and compliance.
2. Professional programmers: from writing to judging
For programmers, the shift is less about disappearance than about where the value sits. When producing code becomes cheap, the scarce skills are the ones that surround it: deciding what to build, specifying it precisely, designing the architecture, testing it, securing it, and judging whether what was generated is actually correct and maintainable.
The effects differ by seniority:
- Junior developers face the most pressure. Many entry-level tasks, such as boilerplate, routine fixes, and simple features, are exactly what AI automates best. That creates a deeper problem: if the on-ramp tasks vanish, how does the next generation of senior engineers learn?
- Senior developers may become more valuable, since judgment, system thinking, and domain knowledge are harder to automate. But their workload changes. They must review far more code, much of it written by machines, and take responsibility for it.
The skills in demand tilt toward evaluating other people’s (and AI’s) code, understanding the business domain, security, and the ability to turn a vague need into a clear specification. It is plausible that the field polarizes, with a smaller number of highly skilled roles and a large amount of automation beneath them. How fast, and how far, remains uncertain.
3. People who program without being programmers
The third group may be the most interesting because it did not meaningfully exist at scale before. People with no formal technical background can now describe what they want and get working software back.
The opportunity is real. Personal automations, custom internal tools, prototypes, and small utilities that would never have justified a developer’s time can now simply exist. The population of software creators expands dramatically, and a great deal of generic, one-size-fits-all software starts to look unnecessary when a tailored version is a conversation away.
The risks are specific to this group:
- Not understanding what you built. When something breaks or needs changing, there is little foundation to fall back on.
- Security and privacy. Vulnerabilities and careless handling of credentials or personal data are easy to miss if you do not know what to look for.
- Silent maintenance debt. Software that works today may fail tomorrow as libraries, services, and platforms change, and the creator may not notice until something goes wrong.
- The illusion of completeness. A convincing prototype is not a dependable product, which is exactly the caution raised about ArtCraft itself.
One risk deserves particular attention because it grows with the size of the project: the limits of working through a chat. A language model only sees what is placed in front of it, and a large application, with hundreds of files and many thousands of lines, does not fit comfortably in a single conversation, and even when it does, the model’s attention to details far back in the exchange tends to degrade. Without a view of the whole, it can duplicate functions, break modules it was never shown, drift between coding conventions, or “fix” one bug by introducing another. An experienced developer notices these inconsistencies because they hold a mental model of the architecture; a non-programmer usually does not, so the project degrades quietly until it fails. Newer agentic tools that read a project folder directly, along with project documentation, automated tests, and version control such as Git, reduce the problem considerably. But they do not remove it, and they still presuppose some basic competence. The result is a rough dividing line: small, well-bounded tools are within reach of non-experts, while large, long-lived systems remain dependent on someone who can manage their complexity.
This group will likely replace a large share of low-stakes, personal, and bespoke software. It is unlikely, at least for now, to replace systems where reliability must be verified.
How the three groups interact
These groups are not independent. As non-experts generate more of their own tools, demand for generic software falls, which pressures the big companies. At the same time, the flood of generated code creates demand for people who can verify it, secure it, and make it robust, which strengthens the case for experienced engineers. And the big companies, using the same AI to cut their own costs, shrink the pool of junior roles inside their own walls.
The big unknown: maintenance
Underneath all of this is a question nobody can yet answer: can AI-built software be sustained over time? Building an impressive prototype is one thing. Keeping a product alive for years, through bug reports, security patches, platform changes, and demanding users, is another.
If long-term maintenance remains hard for AI-generated codebases, incumbents’ advantages will prove more durable than they look today, and projects like ArtCraft will have a long road ahead. If AI also drives down the cost of maintenance, the disruption will be far deeper than anything we have seen so far.
What this means
Software as a mere bundle of features is drifting toward commodity status. What stays valuable is what is hard to copy: trust, integration, data, quality, and accountability. For programmers, the work moves from writing to deciding, designing, and guaranteeing. For everyone else, the barrier to making software has fallen close to the floor, with all the freedom and all the hazards that implies.
ArtCraft may or may not dethrone Adobe. But as a signal, it is hard to ignore: the question is no longer whether people can build clones of expensive software, but what, exactly, anyone is paying for once they can.

