By now you’ve no doubt heard of the ArtCraft software collection, where a group of developers used AI-powered software development tools to build feature-exact clones of the Adobe Creative Suite — and the Microsoft Office suite, and the AutoDesk CAD applications, and the list goes on.
But for me the most striking app ArtCraft has released so far isn’t a clone of an existing app. It’s a relatively original project called Craft Anything — essentially a fancy agent harness for studying existing applications or websites, then prompting an LLM to create your own copy of it, either by reproducing its outward behavior (“clean-room” cloning, as they call it) or by disassembling binaries. You never have to touch a line of code if you don’t want to. It’s the “no-code” dream, pushed to the limit.
We’ve sensed for some time now that with LLM-driven development, anyone can theoretically whip up their own clone of a software program with no programming. What we’re not yet appreciating, I think, is two other consequences:
- That attitude is driving the development of ever-more-abstracted software tools, and transforming existing software tools into more abstracted ones.
- That attitude is also fostering new generations of developers for whom those tools will be their first contact with programming. And possibly also their last.
Let’s start with the tools.
Once upon a time, when dinosaurs roamed the earth and programs lived on paper tape and punch cards, the distance between the programs one wrote and the machines they ran on was very small. Eventually, higher-level languages allowed developers to tackle their problems using human-readable syntax instead of wrangling with hardware-specific machine code. Stories abounded about how the first compilers were received with mixed feelings, because of the abstractions they imposed over the machine. But for decades now we’ve had compilers that write better machine language than we can produce by hand.
Now, it’s those higher-level languages that are next in line to be automated away, or so the argument goes. Let the LLMs write the code, and let the humans focus on higher-order ideas like system architecture. Maybe the natural evolution of creating software is towards greater abstractions. A decade from now, we’ll look back on all the hand-wringing over LLM-generated code and chuckle, because we’ll have accustomed ourselves to the new tools so thoroughly.
What bothers me about this outlook is its fatalism. I don’t think it’s a bad idea to have our choice of levels of abstraction for how we want to write code. I do think it’s a bad idea to believe more abstraction is inevitable, or that it’s always better. The more abstraction we put between ourselves and the work we do, the harder it is to know what might be wrong, or how it might be better.
Now let’s think about what all this is doing to developers.
We haven’t even begun to understand the psychological impacts of LLM use, both on veteran programmers and newcomers. Agents and LLM use don’t exact the same mental toll on developers as do conventional assemblers or compilers. The non-deterministic output of agents makes it harder for developers to reason about the end results of any given prompt. (If an agent never generates the same code twice, is that a bug or a feature?)
Some would say there’s no point in knowing what’s under the hood of LLM-generated code, because the work we’re doing is now happening at such a pace and such a scale that only other machines are equipped to deal with it.
Seductive as that argument is to developers surrounded by impossible deadlines, it feels like the same kind of fatalism. How many of those expectations about velocity are genuine? How much of this LLM-driven work actually results in features shipped, bugs fixed, and value delivered? Those were already hard questions to answer before LLMs came along.
How much abstraction from our work do we really need to develop software? That’s a question we’re going to be far more poorly equipped to understand as we turn over more of the work to AI agents.
And as more of our developers, new and old alike, gravitate towards an agent-first way of doing things, it’s going to be harder for them ever to ask such vital questions in the first place.
Read the original article:
