Hacker News

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 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.

> 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.

> 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.

It's literally called _soft_ware (vs. hardware).

> 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.

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.

> code is a liability, not an asset

This is not the case as far as accounting and the law is concerned.

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 broad in fact. The greeks and more had myths of creation from clay.

https://en.wikipedia.org/wiki/Creation_of_life_from_clay

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'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.

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...

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).

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.?