Code always was, it's supposed to be malleable. It's why it's long been said that code is a liability, not an asset. It's the data you generate with that code that's your asset. You can always rewrite the code.
We, in general, are just very bad at letting code ossify, or for this metaphor, dry out and crumble. AI does not solve this problem and I fully expect to see situations where AI generated code becomes so hard to work with that even LLMs prefer to throw it away and start fresh again.
An expression that stuck with me from the Domain Driven Design book is "supple design". Achieving supple design (and thus supple code) is a goal, but it doesn't come for free - it requires a lot of work. I'm trying hard to get agents to create supple design - or at least not to make my own designs less supple - but it's not easy, because they have a tendency at overcomplicating and overengineering code.
Code was malleable only to a developer with great code comprehension. In my experience, this was actually very rare. I think part of the reason is, you don't get any recognition for modifying a few lines of someone else's code compared to "I created this new library/app to solve this problem for our org!".
I romanticized even before, because there is a reason why society's view of developers shifted from geek losers to rich in the past 15 years. I remember when 15 years ago a girl told me that I'm different, because I'm not as looser as how she imagined developers.
And often, it's not the code that is the issue. You understand the code perfectly fine and can edit it easily. The main issue is always finding out the "why" so you do not remove any Chesterton's fence while coding for a new change request.
The big trick always was to limit your scope. If you can't do that or if your tooling doesn't help you with that then very quickly you will run into the limits of what you can still keep in your head.
Working code that people pay to use is of course an asset. If it is a liability then just delete it all an have no source code an you just paid off a debt for free.
Yes, well-designed code is malleable to an extent when coding by hand, but even then it's an order of magnitude more rigid than when working with agents (and real-world code often ossifies, as you pointed out). Malleability comes not only from the possibility of change but also from the speed.
> It's the data you generate with that code that's your asset. You can always rewrite the code.
I like that perspective, but "you can always rewrite the code" almost never happens in real life for complex projects, and when it does, it's a huge undertaking that takes many months or even years. Malleable code makes that much more feasible, I'd argue.
Rigid implies you are trying to change something into something else in a controlled way. Eg a refactoring that does nothing but enable for a future feature. Agents does not change code to refactor anything, they write code to solve the new feature directly. And if you are good at prompting they might overwrite code that exist so that the end result looks like a refactoring. But no clay was reshaped.
The point is that previously, changing code in a major way might take months of refactoring. Large changes were simply not contemplated unless they were justified by similarly large additional profit. Once you designed your architecture, you were pretty much stuck with it.
Now, the kinds of changes that were simply unrealistic before are now entirely realistic. A refactor/migration that would have taken 6 months before, you can now get a working version done in a day, and another few days of QA. That's what this post means -- code is no longer stone, it's clay. You can change it quickly in ways that were previous unimaginable.
This has nothing to do with the concept of code being liability or asset -- that's a totally separate conversation.
> The point is that previously, changing code in a major way might take months of refactoring.
> Now, the kinds of changes that were simply unrealistic before are now entirely realistic. A refactor/migration that would have taken 6 months before, you can now get a working version done in a day, and another few days of QA.
Significantly changing a system implementation is a function of understanding, not time.
Given a starting solution state being A and a desired functionality state of A', the tooling used to codify the A -> A` delta is largely irrelevant. Specifically, in order to successfully deliver major product realignment requires awareness of what exists currently and understanding of what needs to be.
Code is neither stone nor clay.
When making software, remember that it is a snapshot of
your understanding of the problem. It states to all,
including your future-self, your approach, clarity, and
appropriateness of the solution for the problem at hand.
Choose your statements wisely.
I was watching the most recent Rich Hickey talk[0] and at the start, he talks about correctness and the difference between the internal machinery of your software (which can be finely specified) and handling the external world (which will always be messy).
Good Architecture will try to isolate the two. You got the internal logic which is either the business domain abstracted away. And you got the highly volatile part (request from frontend, new integration, new drivers, deps update,....).
If you've done that, migration/refactoring, unless it entails some unlikely core changes, will not take that long. It's just a matter of dropping that part and replacing it (like changing a car's brake pads or steering wheel). But the actual core mechanism will hardly change over the years.
To go with the thread flow: It's a stone core wrapped by clay.
In regards to separation, one of the best example in mind is the OpenBSD kernel code. The OS concepts are in /kern, while each architecture lives in /arch. There's an horizontal separation between machine independent code (core idea of Unix) and machine dependent code (The hardware platform). It can also be found in the various subsystem like audio (the concept of a sound card) and implementation like uaudio (usb interface) and azalia (Intel's HD Audio).
> Finally, there is the delight of working in such a tractable medium. The programmer, like the poet, works only slightly removed from pure thought-stuff. He builds his castles in the air, from air, creating by the exertion of the imagination. Few media of creation are so flexible, so easy to polish and rework, so readily capable of realizing grand conceptual structures.... https://home.adelphi.edu/sbloch/class/adages/joy.html
Truly spoken as someone who has never worked with legacy code. You know, the kind that's still running Java 1.something when Java was already doing full numbered releases.
The kind that works, but everyone who knows why has left the company. The whole codebase is written in a way that makes automated testing either impossible or so time-consuming that the client will never pay for the required refactoring.
There is way too much code in the world we never were able to rewrite due to real-world concerns. There were people who had the skill, but a part of that skill came with knowing the risks of doing major refactoring to a money-generating system that is ancient, but still works.
Anecdote: I had to work with a system where the original coder (long gone) had rewritten Linked Lists with their custom solution that worked normally except the first X items were the sum, average and mean of the data. Fun times.
We can fully solve 'code' in the sense we can model every single interaction and then use that specification to produce another program that does the exact same thing, and then based on inputs, it should be possible to cull that tree of possibilities even more.
That is my hope anyway, apart from that, I do think there is an inherent laziness in business to not mess with the machine that makes money.
Maybe, but I think one of the points is that the marginal cost of both understanding that legacy code base and safely refactoring it are increasingly trending down thanks to agentic coding tools. It changed the value and risk tradeoff for legacy apps, if deployed properly. There's still a lot of work (too much) to get the harness in place to make high confidence changes to legacy, critical apps. If someone makes that more automated, we'll be in a very different place for legacy refactoring and it will look a lot more like the clay molding the article discusses.
As with anything LLM-related, I feel compelled to ask, is that actually what's happening, or are they just successfully convincing their users that's what's happening? I truly cannot tell.
I'm not using any LLMs directly (my workplace still bans them in-house) and my experience on the receiving end of contractors using them is quite poor. That includes one major, "we'll replace your ancient software with shiny new stuff"... with significantly reduced capability that in turn makes everything far more difficult than it was or ought to be. The UI appears much more user friendly, but really is just broken in multiple ways where the much-patched 1980s software it replaced was user-unfriendly but largely worked.
This all could be the result of poor coding, regardless of LLM use, of course.
With this new-found capability, you can use an LLM to plan and execute some long-needed refactors, or use it to pile on new features even faster with no regard for tech debt management.
As others have said... it's a tool. A powerful tool in the hands of a wise and skilled wielder who makes planned, focused changes, or a slop-cannon in the hands of someone who is happy to churn out features with minimal understanding of context or system design.
I've been able to do relatively big refactors with great success, like porting thousands of lines of data transforms to drastically different data stores practically in one fell swoop. In the background. As I worked on other stuff.
The cost of experimenting is just mind mindbogglingly cheap now, it's really insane. Don't like the abstractions it comes up with, or think it generated a bunch of slop? Go again, who cares? With a little more steering, they'll often produce exactly what you want.
As for contracting firms, many of them were slop shops before AI, I imagine those kinds of firms are even worse slop shops now.
This. Since forever was I told that the term "software" was coined because, contrary to hardware, it was easy to change, adapt, and mold into your needs.
I'm very surprised to hear people in this day and age claim it wasn't.
Someone who writes code without LLMs is now an artisan software developer.
An artisan is (by definition) someone who creates manually, using traditional methods. Before there are automated or higher tech means of creating the same output, artisans don't exist, they are just craftspeople or tradespeople.
A factory worker, or factory owner, can care deeply about the quality of the product, and can be "in the loop" as you write about, but they are in the loop with the factory equipment vs. in the loop in manually crafting the product.
I don't think I'm refuting or in any real disagreement with you, in fact I may be here pushing artisan pedantry because I didn't see the literal use of the term coming through strongly enough.
Author here. No analogy is perfect, but this is how working with code has felt for me for a while, so I wanted to write down my thoughts about it.
I wrote this a couple of months ago, and everything moves so fast nowadays that the concept of factories is already being blurred as harnesses get better and require less tooling around them. I still think that the distinction between wanting to be in the loop vs automated out from it holds up, though.
There are other interesting aspects of malleable code that I don't explore in the article, for example:
- Ownership. People feel less attached to their code, which has both good and bad consequences (e.g. fewer ego battles but less accountability).
- Malleable software that adapt to users. Huge topic, many interesting questions to explore.
- Assets in code. Things like (some) 3D graphics and animations can now be done entirely in code. Before they were very tedious to code and tweak.
- Collaboration dynamics. Instead of high-frequency alignment (discussions, meetings) to make sure every detail is clear before the implementation, it might be more efficient to go ahead with educated guesses and align later over a working build.
What it boils down to is that the future of coding is more about creating the mold where the code is poured in and knowing how exact of a mold is "good enough" for the problem at hand.
When the mold is done, you let the agent pour in the code in any format you like. It can create a Swift version, Rust version and a web assembly version in "half a soda" as you put it =)
The people for whom the only enjoyment in programming was molding the perfect item from scratch will still be needed, but less and less as we get better and faster in defining the molds for the agent to pour the code in.
Before I had to dig specs of an application out of a client's mind and try to form them into software with a full-ass team. Now we can pretty much "just" give them Claude and teach them to describe what they want and iterate to get something that maybe resembles an MVP but in more cases is just an interactive UI spec we can use as a reference to build the actual tool.
> When the mold is done, you let the agent pour in the code in any format you like.
Exactly. And the mold could be a spec, an MVP or even one of the implementations (e.g. the Swift one) acting as the source of truth for the other versions.
> "just" give them Claude and teach them to describe what they want and iterate to get something that maybe resembles an MVP but in more cases is just an interactive UI spec
That's a great example of what malleable code unlocks. You let the client to create the mold themselves, refine it and then use it to properly build the product.
The mold analogy falls apart under even cursory examination: why create a mold in ambiguous uncheckable human languages? Just create a reference implementation.
Nobody said the mold has to be done in a human language. It _can_ be a part of it for the fuzzy bits.
But it's just writing the hard limits on the outside, in code. Define that when A goes in B must come out. Enforce hard linting rules and other code-level checks on the output etc.
> Before I had to dig specs of an application out of a client's mind and try to form them into software with a full-ass team. Now we can pretty much "just" give them Claude and teach them to describe what they want and iterate to get something that maybe resembles an MVP but in more cases is just an interactive UI spec we can use as a reference to build the actual tool.
What are they paying you for if you’re just having your clients vibe code their own apps?
Vibe coding the "feel" and flows of the app - if they know how to do it and what they want.
These are for highly specific stuff like a tool to help a copywriter work on game dialogue for example.
It's a fuckton faster for the actual expert in the field to do it than me first learning enough of their craft to know the terms and how they work to get there eventually.
The actual code that does anything meaningful is made by Actual Programmers. As well as everything beyond that, where it's run the CI pipelines, tests, infrastructure to run it etc.
It's like an architect asking a client to draw and describe their dream home and using it as a basis for the final product.
> What it boils down to is that the future of coding is more about creating the mold where the code is poured in and knowing how exact of a mold is "good enough" for the problem at hand.
> When the mold is done, you let the agent pour in the code in any format you like. It can create a Swift version, Rust version and a web assembly version in "half a soda" as you put it =)
Unless you use code, that mold is at best a formless bag.
The reason people use software is because there's a need to manipulate some data/information, transfer it, and interact with it (input or output). All those actions needs to be done correctly, and if not possible the error should be reported. To get to that level of correctness, we need to be formal with how we express the process, which means essentially going from a non-zero amount of ambiguity (natural language) to zero (programming language).
Using AI to translate specs/prompt to code is just asking it to randomly resolve any ambiguity found in the specs. And as any experienced dev knows, some of those are just tradeoffs where there no right or wrong answers, just contextual ones that evolves over time and space.
> Before I had to dig specs of an application out of a client's mind and try to form them into software with a full-ass team. Now we can pretty much "just" give them Claude and teach them to describe what they want and iterate to get something that maybe resembles an MVP
I wonder if there's actually been conversation with the client before? Where you use some prototyping tools like RAD or Sketch to resolve UI issues, get in touch with the actual domain experts,... or was it just a telephone game full of politics?
Not just specs and prompts, tests, actual procedural limits. No program will ever be perfect[0], but you need to get it good enough for the problem at hand.
A human defines the checks (the mold) that give the agent the limits. They can be TLA+ definitions, linters, cyclomatic complexity checkers, unit tests, integration tests, end to end tests etc. And usually some written docs - made in a way that's specifically targeted at agents. Those define the limits the agent has to stay inside of.
There will always be work for human QA too, an AI can't determine if something feels off in an app's flow, it has no taste or concept of usability beyond the purely mechanical rules.
[0] Not talking about health, aerospace or nuclear stuff here naturally.
This analogy is apt for working with LLMs. Were you aware, tho, that it has repeatedly been used to describe Lisp?
I think Lisp is an ideal language to use with an LLM, because it is essentially a notation for a logical assembly code, and I expect there to be compound benefits in using it with AI.
Lisp [...] made me aware that software could be close to executable mathematics.
— ACM Fellow Profile of L. Peter Deutsch.
APL is like a diamond. It has a beautiful crystal structure; all of its parts are related in a uniform and elegant way. But if you try to extend this structure in any way — even by adding another diamond — you get an ugly kludge. LISP, on the other hand, is like a ball of mud. You can add any amount of mud to it [...] and it still looks like a ball of mud!
— R1RS (1978) page 29, paraphrasing remarks attributed to Joel Moses.
Part of the beauty of the ball-of-mud quote is that there really does seem to be a causal connection between Lisp's use of generic, unencapsulated, largely un-type-checked data structures and its extensibility. The converse implication is that we should expect specialization, encapsulation, and aggressive type-checking of data structures — all strategies extensively pursued in various combinations in modern language paradigms — each to retard language extension.
Each of these three characteristics of Lisp serves to remove some kind of automated restriction on program form, leaving the programmer more responsible for judging what is appropriate — and thereby shifting things away from close conversation with the machine, enabling (though perhaps not actively encouraging) more human engagement. The downside of this is likely obvious to programming veterans: it leaves things more open to human fallibility. Lisp has a reputation as a language for good programmers. (As a remark attributed to Dino Dai Zovi puts it, "We all know that Lisp is the best language around, but in the hands of most it becomes like that scene in Fantasia when Mickey Mouse gets the wand.")
LISP is extensible in two ways. First, there is the simple ability to define new functions; these are used in a way that is both syntactically and semantically identical to built-in primitive functions like CAR. This is in contrast to “algebraic” programming languages, which either make an arbitrary syntactic distinction between addition, say, and a user function, or wander into the quagmire of extensible parsers. Second, there is a uniform macro facility for transforming one syntactic form into another; this facility is based on internal data structures rather than external character-string syntax.
I look forward to the day when the broader industry realizes code was never a bottleneck, and you still have to answer to the market to make money.
This piece, while valid, puts way too much emphasis on code. I don’t want to dismiss the author, but they’ve yet to see how little of a shit the business gives about code. This has been perennial.
Some development houses have always done sketches, proof of concepts or prototypes. Not because code was expensive or inmalleable, but because they didn’t know what would be a success. Even if it did not take forever to build the thing. If I told you what the perfect product was and how to make a boatload of money, you’d be ready with an army of programmers. But life and business rarely work out that way.
So you've NEVER had a sketch, proof of concept or prototype end up being a part of the final product? Now you're stuck with a piece of crap that was implemented expecting to be thrown away, but then because of time and money constraints it's now a load-bearing (heh) part of the application.
It also takes more time for humans to build prototypes and PoCs than doing the same with an agent. Iteration speed and time-to-market matters more and more (case in point: mobile games).
Fun facts, Abrahamic religions that are based on the Bible and Quran both claiming human are made from clay [1],[2].
In Hebrew name Adam, the very first human, comes from the word adamah, which means "ground," "soil," or "red clay".
In Arabic Adam, comes from the word adeem, means the surface of the earth or dust, reflecting the Islamic and Abrahamic tradition that Adam was created from the clay or dust of the ground.
By extension in Hebrew and Arabic the word Adam also means mankind and humanity.
In Chinese mythology, human beings were also created from clay. The goddess Nüwa first came to an empty river bank and spent much time carefully crafting a set of figures, then got tired, and rushed together a bunch of clay piles using a length of corded rope. The first group of clay figures were the nobility, while the latter were the commoners.
Very cool, thanks for that. I was vaguely aware that clay metaphors were important in several religions, and I thought about looking into it and maybe finding a nice quote for the article, but didn't have the time (I accept suggestions, though!)
I'm not sure clay is the best analogy; at some point it just comes rigid and you have to throw it out. In which case if that was always the case, nothing really changed.
What we've done though is really reduce the cost of clay and its availability.
Good clay was expensive to come by, not cheap and difficult to procure, now it's wildly available.
A good developer now will have to be better to think and communicate as the code quality is becoming less important. I don't like it but it's the world we live in.
Just to pick a little at your anti-analogy, when good clay dries out you never throw it away-- you put it in the bucket to make slip. Then when you need it you take it out, re-work it, and use it on a different project.
> Clay is a data visualization and literate programming tool that creates documents (HTML pages, PDFs, books, blog posts, reports, slideshows) from Clojure source code and comments.
I guess it's more of a computational notebook or interactive environment.
So not only the code but the running program and the editing environment itself is clay.
There's also another sticky, malleable substance that could work for this analogy...
But more seriously: the question, the same as before, is "what are you going to sculpt". Sculpting for the sake of sculpting achieves nothing, and if it's too cheap and too easy, it can cost you time and money than if you had to pause and think beforehand.
I implore you to look at the past several months of vibecoded games and Github projects submitted to HN. It's amazing that you can prototype something in hours. It's bleak when you realize that half of these projects weren't even working properly - we often upvote based on vibes too - and are now abandoned in a half-broken state because the author has no attachment to it whatsoever. It was just some money exchanged for internet points.
There's no doubt that we're going to have more software; I think it's very much an open question whether there's going to be more good software, or more software that can make money.
Agreed, clay/modeling it is a good analogy. I keep trying to describe the level I work at now (if only to myself) and all I could conjure was shaping the product at a higher level with less control overall (unless you want to drop down and do some "detail work") but the ability to make sweeping changes much easier.
Good code was clay anyway. The entire point of decades of research into software engineering and architecture is to keep code malleable. It's literally in the name: soft-ware.
But what good architecture gives us is the ability to move slowly and methodically. No we don't just knock down the edifice and start from scratch every time. We change the bits that matter with surgical precision, or write a new plugin to extend the capabilities into an unforeseen direction.
I'd actually say LLMs are less likely to treat code as clay, what with their zeal for implementing things completely from scratch and ignoring existing architecture and conventions.
Everyone is saying this about "the factory." I have seen some successful fix and migrate campaigns for well-defined, local transformations such as retroactive fixes for new lint rules, flaky tests, or library migrations. But so far the attempts to do nontrivial new functionality in this manner have made big messes that take more effort to review and correct than simply hand-feeding 1-3 vanilla Claude Code sessions with my full attention.
To torture the analogy a bit: You didn't sculpt bridges out of clay - critical infrastructure was built from stone. Even if you wanted to use clay, you made bricks, and architected the structure from those units. You couldn't just throw a lump of clay across a stream and vibe-build a bridge...
If we want to use LLMs responsibly, to build substantial pieces of infrastructure, we should be using it to create discreet "bricks" of code, that can be tested, relied upon, and used to implement human-driven architectural decisions.
I prefer the 'code is legos' metaphor. Well defined interfaces that hurt like hell if you step on them. You get a practically indestructible chunk that is simple by itself but can be composed to extreme complexity. Parts can be used in many different contexts and new parts are constructed when required. I think AI actually increases the need for this kind of construction.
Code is clay now, agents have surpassed most human coders, arguably arriving at AGI. Yet the team at Hacker News STILL can't figure out how to make their forum software bump a post without these embarrassing fake time stamps.
That's a fascinating topic. I'm curious about how do you approach it... like can the user-facing AI change any part of the code? Or is it constrained to a set of predefined components/plugin layer/etc.?
So I have the app deployed to railway with a Postgres database. I give the customer an agent that has the railway skill and basically access to that customers project on railway and they can talk to the agent and it can communicate with app, change the code deploy it again, do migrations.
I remember explaining software to someone, and I explained that it was like a sandpit, every day - it is cleared, you make shapes, lines, add rocks, toys - surely, at the end of the day, it gets cleared, and starts again new the next day.
What remains are the lessons we learnt, the sand is a medium through which we express ourselves.
Code is more like a garden. You spend a lot of time just watching stuff grow, you don't know what you're going to get, sometimes you have to pull weeds, and you have to be mindful of the weather and soil conditions to ensure stuff grows optimally.
And it is still better to be a coder in a garden, than a gardener in CODE.
Code always was, it's supposed to be malleable. It's why it's long been said that code is a liability, not an asset. It's the data you generate with that code that's your asset. You can always rewrite the code.
We, in general, are just very bad at letting code ossify, or for this metaphor, dry out and crumble. AI does not solve this problem and I fully expect to see situations where AI generated code becomes so hard to work with that even LLMs prefer to throw it away and start fresh again.
An expression that stuck with me from the Domain Driven Design book is "supple design". Achieving supple design (and thus supple code) is a goal, but it doesn't come for free - it requires a lot of work. I'm trying hard to get agents to create supple design - or at least not to make my own designs less supple - but it's not easy, because they have a tendency at overcomplicating and overengineering code.
Code was malleable only to a developer with great code comprehension. In my experience, this was actually very rare. I think part of the reason is, you don't get any recognition for modifying a few lines of someone else's code compared to "I created this new library/app to solve this problem for our org!".
The problem has always been that code is malleable for all including those that think that have great code comprehension but actually don't.
> Code was malleable only to a developer with great code comprehension
This used to be what being a dev was, if I recall. It's been a few years.
I think we romanticise the old days of coding now that agents are doing it.
Regarding the average developer as an imbecile was a cottage industry from Djikstra to FizzBuzz.
I romanticized even before, because there is a reason why society's view of developers shifted from geek losers to rich in the past 15 years. I remember when 15 years ago a girl told me that I'm different, because I'm not as looser as how she imagined developers.
Sure, but it was certainly a difference between those projects you authored and those you inherited, at least in time-to-productiveness.
The ability to understand and maintain inherited projects is more valuable than the ability to create new greenfield projects.
In terms of value as an income, then for a consultant this is most likely true - for staff working in a megacorp not so much.
And often, it's not the code that is the issue. You understand the code perfectly fine and can edit it easily. The main issue is always finding out the "why" so you do not remove any Chesterton's fence while coding for a new change request.
People with poor comprehension have been changing code for years, and in great numbers. Doesn't mean it goes well, mind you.
The big trick always was to limit your scope. If you can't do that or if your tooling doesn't help you with that then very quickly you will run into the limits of what you can still keep in your head.
Working code that people pay to use is of course an asset. If it is a liability then just delete it all an have no source code an you just paid off a debt for free.
> Code always was, it's supposed to be malleable
Yes, well-designed code is malleable to an extent when coding by hand, but even then it's an order of magnitude more rigid than when working with agents (and real-world code often ossifies, as you pointed out). Malleability comes not only from the possibility of change but also from the speed.
> It's the data you generate with that code that's your asset. You can always rewrite the code.
I like that perspective, but "you can always rewrite the code" almost never happens in real life for complex projects, and when it does, it's a huge undertaking that takes many months or even years. Malleable code makes that much more feasible, I'd argue.
Rigid implies you are trying to change something into something else in a controlled way. Eg a refactoring that does nothing but enable for a future feature. Agents does not change code to refactor anything, they write code to solve the new feature directly. And if you are good at prompting they might overwrite code that exist so that the end result looks like a refactoring. But no clay was reshaped.
The agent looks at the previous code base to extract specs. So reuse of some tokkens?
I think you may be misunderstanding.
The point is that previously, changing code in a major way might take months of refactoring. Large changes were simply not contemplated unless they were justified by similarly large additional profit. Once you designed your architecture, you were pretty much stuck with it.
Now, the kinds of changes that were simply unrealistic before are now entirely realistic. A refactor/migration that would have taken 6 months before, you can now get a working version done in a day, and another few days of QA. That's what this post means -- code is no longer stone, it's clay. You can change it quickly in ways that were previous unimaginable.
This has nothing to do with the concept of code being liability or asset -- that's a totally separate conversation.
This is fantasy though.
The reason code takes time to change is not because changing it takes time.
You have to redo all the testing and relearn all the hard fought and underspecified lessons of the previous attempt. That's what takes the time.
> The point is that previously, changing code in a major way might take months of refactoring.
> Now, the kinds of changes that were simply unrealistic before are now entirely realistic. A refactor/migration that would have taken 6 months before, you can now get a working version done in a day, and another few days of QA.
Significantly changing a system implementation is a function of understanding, not time.
Given a starting solution state being A and a desired functionality state of A', the tooling used to codify the A -> A` delta is largely irrelevant. Specifically, in order to successfully deliver major product realignment requires awareness of what exists currently and understanding of what needs to be.
Code is neither stone nor clay.
I was watching the most recent Rich Hickey talk[0] and at the start, he talks about correctness and the difference between the internal machinery of your software (which can be finely specified) and handling the external world (which will always be messy).
Good Architecture will try to isolate the two. You got the internal logic which is either the business domain abstracted away. And you got the highly volatile part (request from frontend, new integration, new drivers, deps update,....).
If you've done that, migration/refactoring, unless it entails some unlikely core changes, will not take that long. It's just a matter of dropping that part and replacing it (like changing a car's brake pads or steering wheel). But the actual core mechanism will hardly change over the years.
To go with the thread flow: It's a stone core wrapped by clay.
[0]: https://www.youtube.com/watch?v=P5eO7BNyJao
ADDENDUM
In regards to separation, one of the best example in mind is the OpenBSD kernel code. The OS concepts are in /kern, while each architecture lives in /arch. There's an horizontal separation between machine independent code (core idea of Unix) and machine dependent code (The hardware platform). It can also be found in the various subsystem like audio (the concept of a sound card) and implementation like uaudio (usb interface) and azalia (Intel's HD Audio).
> AI does not solve this problem
AI absolutely solves that problem. Just about every prompt "fixes" the dried out pieces of the code. And it's only getting better at that every month.
Sometimes I feel like people are experiencing AI so differently that it makes talking about it nearly impossible.
> Finally, there is the delight of working in such a tractable medium. The programmer, like the poet, works only slightly removed from pure thought-stuff. He builds his castles in the air, from air, creating by the exertion of the imagination. Few media of creation are so flexible, so easy to polish and rework, so readily capable of realizing grand conceptual structures.... https://home.adelphi.edu/sbloch/class/adages/joy.html
Dependency is a cause of ossification.
Truly spoken as someone who has never worked with legacy code. You know, the kind that's still running Java 1.something when Java was already doing full numbered releases.
The kind that works, but everyone who knows why has left the company. The whole codebase is written in a way that makes automated testing either impossible or so time-consuming that the client will never pay for the required refactoring.
There is way too much code in the world we never were able to rewrite due to real-world concerns. There were people who had the skill, but a part of that skill came with knowing the risks of doing major refactoring to a money-generating system that is ancient, but still works.
Anecdote: I had to work with a system where the original coder (long gone) had rewritten Linked Lists with their custom solution that worked normally except the first X items were the sum, average and mean of the data. Fun times.
We can fully solve 'code' in the sense we can model every single interaction and then use that specification to produce another program that does the exact same thing, and then based on inputs, it should be possible to cull that tree of possibilities even more.
That is my hope anyway, apart from that, I do think there is an inherent laziness in business to not mess with the machine that makes money.
If you don't do the work to separate the actual specifications from what the legacy app happens to do then why are you even rewriting it?
Maybe, but I think one of the points is that the marginal cost of both understanding that legacy code base and safely refactoring it are increasingly trending down thanks to agentic coding tools. It changed the value and risk tradeoff for legacy apps, if deployed properly. There's still a lot of work (too much) to get the harness in place to make high confidence changes to legacy, critical apps. If someone makes that more automated, we'll be in a very different place for legacy refactoring and it will look a lot more like the clay molding the article discusses.
As with anything LLM-related, I feel compelled to ask, is that actually what's happening, or are they just successfully convincing their users that's what's happening? I truly cannot tell.
I'm not using any LLMs directly (my workplace still bans them in-house) and my experience on the receiving end of contractors using them is quite poor. That includes one major, "we'll replace your ancient software with shiny new stuff"... with significantly reduced capability that in turn makes everything far more difficult than it was or ought to be. The UI appears much more user friendly, but really is just broken in multiple ways where the much-patched 1980s software it replaced was user-unfriendly but largely worked.
This all could be the result of poor coding, regardless of LLM use, of course.
With this new-found capability, you can use an LLM to plan and execute some long-needed refactors, or use it to pile on new features even faster with no regard for tech debt management.
As others have said... it's a tool. A powerful tool in the hands of a wise and skilled wielder who makes planned, focused changes, or a slop-cannon in the hands of someone who is happy to churn out features with minimal understanding of context or system design.
I've been able to do relatively big refactors with great success, like porting thousands of lines of data transforms to drastically different data stores practically in one fell swoop. In the background. As I worked on other stuff.
The cost of experimenting is just mind mindbogglingly cheap now, it's really insane. Don't like the abstractions it comes up with, or think it generated a bunch of slop? Go again, who cares? With a little more steering, they'll often produce exactly what you want.
As for contracting firms, many of them were slop shops before AI, I imagine those kinds of firms are even worse slop shops now.
> I fully expect to see situations where AI generated code becomes so hard to work with that even LLMs prefer to throw it away and start fresh again.
You know, I've never thought about that. It's really interesting to consider, especially since refactoring code is now cheaper than ever.
It's literally called _soft_ware (vs. hardware).
Clod (claude?) of Clay.
> It's the data you generate with that code that's your asset.
Not sure what kind of data this refers to?
> Code always was, it's supposed to be malleable.
This. Since forever was I told that the term "software" was coined because, contrary to hardware, it was easy to change, adapt, and mold into your needs.
I'm very surprised to hear people in this day and age claim it wasn't.
> code is a liability, not an asset
This is not the case as far as accounting and the law is concerned.
The “soft” suffix in software means exactly that: logic that is easy to change.
Unlike hardware circuits, where logic is harder to change.
Someone who writes code without LLMs is now an artisan software developer.
An artisan is (by definition) someone who creates manually, using traditional methods. Before there are automated or higher tech means of creating the same output, artisans don't exist, they are just craftspeople or tradespeople.
A factory worker, or factory owner, can care deeply about the quality of the product, and can be "in the loop" as you write about, but they are in the loop with the factory equipment vs. in the loop in manually crafting the product.
I don't think I'm refuting or in any real disagreement with you, in fact I may be here pushing artisan pedantry because I didn't see the literal use of the term coming through strongly enough.
Author here. No analogy is perfect, but this is how working with code has felt for me for a while, so I wanted to write down my thoughts about it.
I wrote this a couple of months ago, and everything moves so fast nowadays that the concept of factories is already being blurred as harnesses get better and require less tooling around them. I still think that the distinction between wanting to be in the loop vs automated out from it holds up, though.
There are other interesting aspects of malleable code that I don't explore in the article, for example:
- Ownership. People feel less attached to their code, which has both good and bad consequences (e.g. fewer ego battles but less accountability).
- Malleable software that adapt to users. Huge topic, many interesting questions to explore.
- Assets in code. Things like (some) 3D graphics and animations can now be done entirely in code. Before they were very tedious to code and tweak.
- Collaboration dynamics. Instead of high-frequency alignment (discussions, meetings) to make sure every detail is clear before the implementation, it might be more efficient to go ahead with educated guesses and align later over a working build.
I've came up with the same basic analogy as you.
What it boils down to is that the future of coding is more about creating the mold where the code is poured in and knowing how exact of a mold is "good enough" for the problem at hand.
When the mold is done, you let the agent pour in the code in any format you like. It can create a Swift version, Rust version and a web assembly version in "half a soda" as you put it =)
The people for whom the only enjoyment in programming was molding the perfect item from scratch will still be needed, but less and less as we get better and faster in defining the molds for the agent to pour the code in.
Before I had to dig specs of an application out of a client's mind and try to form them into software with a full-ass team. Now we can pretty much "just" give them Claude and teach them to describe what they want and iterate to get something that maybe resembles an MVP but in more cases is just an interactive UI spec we can use as a reference to build the actual tool.
> When the mold is done, you let the agent pour in the code in any format you like.
Exactly. And the mold could be a spec, an MVP or even one of the implementations (e.g. the Swift one) acting as the source of truth for the other versions.
> "just" give them Claude and teach them to describe what they want and iterate to get something that maybe resembles an MVP but in more cases is just an interactive UI spec
That's a great example of what malleable code unlocks. You let the client to create the mold themselves, refine it and then use it to properly build the product.
The mold analogy falls apart under even cursory examination: why create a mold in ambiguous uncheckable human languages? Just create a reference implementation.
Otherwise, create a "mold" in AST in Lisp.
Nobody said the mold has to be done in a human language. It _can_ be a part of it for the fuzzy bits.
But it's just writing the hard limits on the outside, in code. Define that when A goes in B must come out. Enforce hard linting rules and other code-level checks on the output etc.
> Before I had to dig specs of an application out of a client's mind and try to form them into software with a full-ass team. Now we can pretty much "just" give them Claude and teach them to describe what they want and iterate to get something that maybe resembles an MVP but in more cases is just an interactive UI spec we can use as a reference to build the actual tool.
What are they paying you for if you’re just having your clients vibe code their own apps?
Vibe coding the "feel" and flows of the app - if they know how to do it and what they want.
These are for highly specific stuff like a tool to help a copywriter work on game dialogue for example.
It's a fuckton faster for the actual expert in the field to do it than me first learning enough of their craft to know the terms and how they work to get there eventually.
The actual code that does anything meaningful is made by Actual Programmers. As well as everything beyond that, where it's run the CI pipelines, tests, infrastructure to run it etc.
It's like an architect asking a client to draw and describe their dream home and using it as a basis for the final product.
> What it boils down to is that the future of coding is more about creating the mold where the code is poured in and knowing how exact of a mold is "good enough" for the problem at hand.
> When the mold is done, you let the agent pour in the code in any format you like. It can create a Swift version, Rust version and a web assembly version in "half a soda" as you put it =)
Unless you use code, that mold is at best a formless bag.
The reason people use software is because there's a need to manipulate some data/information, transfer it, and interact with it (input or output). All those actions needs to be done correctly, and if not possible the error should be reported. To get to that level of correctness, we need to be formal with how we express the process, which means essentially going from a non-zero amount of ambiguity (natural language) to zero (programming language).
Using AI to translate specs/prompt to code is just asking it to randomly resolve any ambiguity found in the specs. And as any experienced dev knows, some of those are just tradeoffs where there no right or wrong answers, just contextual ones that evolves over time and space.
> Before I had to dig specs of an application out of a client's mind and try to form them into software with a full-ass team. Now we can pretty much "just" give them Claude and teach them to describe what they want and iterate to get something that maybe resembles an MVP
I wonder if there's actually been conversation with the client before? Where you use some prototyping tools like RAD or Sketch to resolve UI issues, get in touch with the actual domain experts,... or was it just a telephone game full of politics?
Not just specs and prompts, tests, actual procedural limits. No program will ever be perfect[0], but you need to get it good enough for the problem at hand.
A human defines the checks (the mold) that give the agent the limits. They can be TLA+ definitions, linters, cyclomatic complexity checkers, unit tests, integration tests, end to end tests etc. And usually some written docs - made in a way that's specifically targeted at agents. Those define the limits the agent has to stay inside of.
There will always be work for human QA too, an AI can't determine if something feels off in an app's flow, it has no taste or concept of usability beyond the purely mechanical rules.
[0] Not talking about health, aerospace or nuclear stuff here naturally.
Related:
Malleable Systems Collective
https://news.ycombinator.com/item?id=50188437
This analogy is apt for working with LLMs. Were you aware, tho, that it has repeatedly been used to describe Lisp?
I think Lisp is an ideal language to use with an LLM, because it is essentially a notation for a logical assembly code, and I expect there to be compound benefits in using it with AI.
Lisp [...] made me aware that software could be close to executable mathematics.
— ACM Fellow Profile of L. Peter Deutsch.
APL is like a diamond. It has a beautiful crystal structure; all of its parts are related in a uniform and elegant way. But if you try to extend this structure in any way — even by adding another diamond — you get an ugly kludge. LISP, on the other hand, is like a ball of mud. You can add any amount of mud to it [...] and it still looks like a ball of mud!
— R1RS (1978) page 29, paraphrasing remarks attributed to Joel Moses.
Part of the beauty of the ball-of-mud quote is that there really does seem to be a causal connection between Lisp's use of generic, unencapsulated, largely un-type-checked data structures and its extensibility. The converse implication is that we should expect specialization, encapsulation, and aggressive type-checking of data structures — all strategies extensively pursued in various combinations in modern language paradigms — each to retard language extension.
Each of these three characteristics of Lisp serves to remove some kind of automated restriction on program form, leaving the programmer more responsible for judging what is appropriate — and thereby shifting things away from close conversation with the machine, enabling (though perhaps not actively encouraging) more human engagement. The downside of this is likely obvious to programming veterans: it leaves things more open to human fallibility. Lisp has a reputation as a language for good programmers. (As a remark attributed to Dino Dai Zovi puts it, "We all know that Lisp is the best language around, but in the hands of most it becomes like that scene in Fantasia when Mickey Mouse gets the wand.")
Lisp, Mud, and Wikis
https://fexpr.blogspot.com/2018/10/lisp-mud-and-wikis.html#s...
{LISP Is a Ball of Mud}
LISP is extensible in two ways. First, there is the simple ability to define new functions; these are used in a way that is both syntactically and semantically identical to built-in primitive functions like CAR. This is in contrast to “algebraic” programming languages, which either make an arbitrary syntactic distinction between addition, say, and a user function, or wander into the quagmire of extensible parsers. Second, there is a uniform macro facility for transforming one syntactic form into another; this facility is based on internal data structures rather than external character-string syntax.
The Revised Report on Scheme
https://research.scheme.org/lambda-papers/lambda-papers-revi...
https://wiki.c2.com/?HackerLanguage
Also:
Lisp is Clay: The Power of Composable DSLs (video)
https://archive.fosdem.org/2026/schedule/event/HDE7JZ-lisp-i...
My current analogy for code/programming is currently related to cooking: ai coding agents are the new Thermomix.
I look forward to the day when the broader industry realizes code was never a bottleneck, and you still have to answer to the market to make money.
This piece, while valid, puts way too much emphasis on code. I don’t want to dismiss the author, but they’ve yet to see how little of a shit the business gives about code. This has been perennial.
Some development houses have always done sketches, proof of concepts or prototypes. Not because code was expensive or inmalleable, but because they didn’t know what would be a success. Even if it did not take forever to build the thing. If I told you what the perfect product was and how to make a boatload of money, you’d be ready with an army of programmers. But life and business rarely work out that way.
So you've NEVER had a sketch, proof of concept or prototype end up being a part of the final product? Now you're stuck with a piece of crap that was implemented expecting to be thrown away, but then because of time and money constraints it's now a load-bearing (heh) part of the application.
It also takes more time for humans to build prototypes and PoCs than doing the same with an agent. Iteration speed and time-to-market matters more and more (case in point: mobile games).
> how little of a shit the business gives about code
Very true.
Very apt comparison and analogy.
Fun facts, Abrahamic religions that are based on the Bible and Quran both claiming human are made from clay [1],[2].
In Hebrew name Adam, the very first human, comes from the word adamah, which means "ground," "soil," or "red clay".
In Arabic Adam, comes from the word adeem, means the surface of the earth or dust, reflecting the Islamic and Abrahamic tradition that Adam was created from the clay or dust of the ground.
By extension in Hebrew and Arabic the word Adam also means mankind and humanity.
[1] Genesis 2:7:
https://www.biblegateway.com/passage/?search=Genesis%202%3A7...
[2] Quran 7:12:
https://quran.com/al-araf/12
In Chinese mythology, human beings were also created from clay. The goddess Nüwa first came to an empty river bank and spent much time carefully crafting a set of figures, then got tired, and rushed together a bunch of clay piles using a length of corded rope. The first group of clay figures were the nobility, while the latter were the commoners.
interesting, wonder which class promulgated that myth
Very cool, thanks for that. I was vaguely aware that clay metaphors were important in several religions, and I thought about looking into it and maybe finding a nice quote for the article, but didn't have the time (I accept suggestions, though!)
Very broad in fact. The greeks and more had myths of creation from clay.
https://en.wikipedia.org/wiki/Creation_of_life_from_clay
I'm not sure clay is the best analogy; at some point it just comes rigid and you have to throw it out. In which case if that was always the case, nothing really changed.
What we've done though is really reduce the cost of clay and its availability.
Good clay was expensive to come by, not cheap and difficult to procure, now it's wildly available.
A good developer now will have to be better to think and communicate as the code quality is becoming less important. I don't like it but it's the world we live in.
Just to pick a little at your anti-analogy, when good clay dries out you never throw it away-- you put it in the bucket to make slip. Then when you need it you take it out, re-work it, and use it on a different project.
There’s a DRY (don’t repeat yourself) joke in there somewhere
The way code actually becomes clay, without needing a clay-wielding robot to do things for you, is to work in a material from the Lisp family.
Lisps have been compared to clay historically; search for it.
Recently, FOSDEM 2026 talk title: https://archive.fosdem.org/2026/schedule/event/HDE7JZ-lisp-i...
Not so recently, 1978 Revised Report on SCHEME: https://research.scheme.org/lambda-papers/lambda-papers-revi... ("LISP is a ball of mud" note)
Rephrased as "clay" in 1980 "Lisp Comes of Age" article for Byte Magazine: https://microship.com/lisp-comes-of-age/
There's even an editor (?) for Lisp called Clay.
https://scicloj.github.io/clay/
> Clay is a data visualization and literate programming tool that creates documents (HTML pages, PDFs, books, blog posts, reports, slideshows) from Clojure source code and comments.
I guess it's more of a computational notebook or interactive environment.
So not only the code but the running program and the editing environment itself is clay.
There's also another sticky, malleable substance that could work for this analogy...
But more seriously: the question, the same as before, is "what are you going to sculpt". Sculpting for the sake of sculpting achieves nothing, and if it's too cheap and too easy, it can cost you time and money than if you had to pause and think beforehand.
I implore you to look at the past several months of vibecoded games and Github projects submitted to HN. It's amazing that you can prototype something in hours. It's bleak when you realize that half of these projects weren't even working properly - we often upvote based on vibes too - and are now abandoned in a half-broken state because the author has no attachment to it whatsoever. It was just some money exchanged for internet points.
There's no doubt that we're going to have more software; I think it's very much an open question whether there's going to be more good software, or more software that can make money.
Agreed, clay/modeling it is a good analogy. I keep trying to describe the level I work at now (if only to myself) and all I could conjure was shaping the product at a higher level with less control overall (unless you want to drop down and do some "detail work") but the ability to make sweeping changes much easier.
Good code was clay anyway. The entire point of decades of research into software engineering and architecture is to keep code malleable. It's literally in the name: soft-ware.
But what good architecture gives us is the ability to move slowly and methodically. No we don't just knock down the edifice and start from scratch every time. We change the bits that matter with surgical precision, or write a new plugin to extend the capabilities into an unforeseen direction.
I'd actually say LLMs are less likely to treat code as clay, what with their zeal for implementing things completely from scratch and ignoring existing architecture and conventions.
Everyone is saying this about "the factory." I have seen some successful fix and migrate campaigns for well-defined, local transformations such as retroactive fixes for new lint rules, flaky tests, or library migrations. But so far the attempts to do nontrivial new functionality in this manner have made big messes that take more effort to review and correct than simply hand-feeding 1-3 vanilla Claude Code sessions with my full attention.
To torture the analogy a bit: You didn't sculpt bridges out of clay - critical infrastructure was built from stone. Even if you wanted to use clay, you made bricks, and architected the structure from those units. You couldn't just throw a lump of clay across a stream and vibe-build a bridge...
If we want to use LLMs responsibly, to build substantial pieces of infrastructure, we should be using it to create discreet "bricks" of code, that can be tested, relied upon, and used to implement human-driven architectural decisions.
I prefer the 'code is legos' metaphor. Well defined interfaces that hurt like hell if you step on them. You get a practically indestructible chunk that is simple by itself but can be composed to extreme complexity. Parts can be used in many different contexts and new parts are constructed when required. I think AI actually increases the need for this kind of construction.
> we coder-stonemasons spent our days meticulously carving code-stone into finished pieces
In what world this was ever true ? a software or a lib is pretty much never finished
Code is clay now, agents have surpassed most human coders, arguably arriving at AGI. Yet the team at Hacker News STILL can't figure out how to make their forum software bump a post without these embarrassing fake time stamps.
- i still write my code by hand and ll continue to do so
- only thing I use AI for is to review it
I came to the exact conclusion anology myself. So there is something to it.
It's actually Pokemon, but you can crossbreed and genetically modify them.
I’m working on many open-source SaaS and am working on making them malleable from the built in AI. Anyone else working on this?
That's a fascinating topic. I'm curious about how do you approach it... like can the user-facing AI change any part of the code? Or is it constrained to a set of predefined components/plugin layer/etc.?
So I have the app deployed to railway with a Postgres database. I give the customer an agent that has the railway skill and basically access to that customers project on railway and they can talk to the agent and it can communicate with app, change the code deploy it again, do migrations.
I remember explaining software to someone, and I explained that it was like a sandpit, every day - it is cleared, you make shapes, lines, add rocks, toys - surely, at the end of the day, it gets cleared, and starts again new the next day.
What remains are the lessons we learnt, the sand is a medium through which we express ourselves.
Code might be clay, but we're not at the potter's wheel any more, the clankers are.
It's literally the Disney Fantasia scene of the Sorcerer's Apprentice: https://www.youtube.com/watch?v=m-W8vUXRfxU
Is it no longer gauche to refer to oneself as an artisan?
Opinions are mud now
I've always thought of it as a sand mandala.
Code is more like a garden. You spend a lot of time just watching stuff grow, you don't know what you're going to get, sometimes you have to pull weeds, and you have to be mindful of the weather and soil conditions to ensure stuff grows optimally.
And it is still better to be a coder in a garden, than a gardener in CODE.
code has been clay for 4+ decades now, kiddos, I can confirm firsthand
Now that we have AI, we can literally and figuratively boil the ocean to... program computers to do what we want them to do!
The oceans were constructed for us humans. And now you want to boil it? Why?
https://youtu.be/t462tTJQxuA?t=6328
This is just current day LLM consumer conceit packaged as information.