I've said for a long time that composability in software is a bit like playing Tetris: the lines have to clear.
I feel like that gives an even more literal tower-rising metaphor, and that's what it feels like people using agents naively (and software engineers of lower skill or earlier-career), end up violating.
Agents are getting better at folding things into themselves, especially if you direct them to... but unfortunately I've found that the architectural instincts, even of Fable and 5.6 Sol, are still wildly behind what I reflexively achieve, say.
For sure there is an ability to have agents go back over work and try to fold it into better and better abstractions until it's sort of annealed into something good. I've done something similar on codebases that I have, but the 'high reaches' of architecture with great _prediction of how the software will evolve in the future_ in _subtle_ ways – those are, for now, out of reach of agents.
There is a part of me that wonders if it's partly just how much they can hold in their head right now, though. Even with the greatest articulation and high density of feeding them, the current setups don't allow them to hold a high-quality, sparse, 'zoomable' model of the world in their head that well yet, which we can do pretty well.
But the fact that I'm talking about it in terms of that kind of subtlety is itself promising, I guess?
The upper bound on program complexity used to be the power of the human mind.
"Vibe coding" can break through that barrier. But not because the problem being solved needs that complexity. Because the process does not drive itself towards compact abstractions. It's the AI-powered version of the scaling problem Brooks described back in "The Mythical Man-Month". The combinatoric problems get worse with scale. Concretely, multiple similar implementations of roughly the same thing appear in different parts of the project. This is a known problem of vibe coding now.
We need some way to make AI-driven coding strive for parsimony.
Why would it? It has optimized what it was built to optimize: this is the token-selling industry. Take note that the people hawking the dream of a gold rush are not actually mining but selling shovels
Same issue happens in models trained by organizations who aren’t selling tokens. I believe it’s because being parsimonious is simply harder. Achieving the task at hand independently and declaring the job done is easier than building an abstraction and reconciling between every use case.
Labs are trying to make long-horizon work. Even if you're a coding agent, adding more and more surface area is distracting to that goal. There is reason that RL over long traces should, at least in principle, optimize for building in ways that help the result fit in the model's context window.
A meaningful risk of course is that the tools available to the model (ripgrep + fancier semantic approaches) allow it to do a good job of reasoning over things much larger than its context window, and so it doesn't pay the penalty sufficiently to fix it.
Does that not sound a little silly to you when you say it? Should I invest in becoming a memory athlete as a way of becoming a better software engineer? ...or should I learn how to build and use tools?
> "Vibe coding" can break through that barrier. But not because the problem being solved needs that complexity. Because the process does not drive itself towards compact abstractions.
It's the infinite AI monkeys at a computer keyboard phenomenon.
Or the car on the highway that bumps left and right on the guardrails until, eventually, it arrives at its destination and nearly everybody is amazed at that great success.
The AI kool-aid drinkers are going to answer: "but that's how human code too".
Absolutely this: and it needs to ideally become the kind of set of abstractions that mean that every new thing added uses less net-new surface area than it would without them.
Microservices are about separate deployment. Regarding separating the development/maintenance of components, you can achieve that in a monolith by composing it out of corresponding modules/libraries with defined APIs. That’s good practice anyway.
Unless we are planning to deploy them all individually to an expensive serverless platform like Lambda, the coordination challenges and overprovisioning are going to more than outweigh whatever architectural benefit you reap (in human-centred development, micro services are solving an entirely different problem - Conway's Law)
Agreed, and ever since LLMs started being able to write competent code, I've noticed a massive difference in quality on codebases where I knew the technology, and ones I didn't. This is because I can much more efficiently steer the LLM on e.g. backend code, which is my expertise, vs yoloing everything on mobile, where I have no idea.
The codebases using technologies I have no idea about tend to quickly become unmaintainable and buggy, because the LLM still doesn't make good architectural choices, but the codebases that use technologies I'm familiar with basically never devolve into unmaintainability.
The difference between the two is massive, and that's why I think that a competent engineer steering an LLM in their area of expertise gets two orders of magnitude more productive, whereas someone steering an LLM in an area they know nothing about are basically producing tech debt at the speed of thought.
> But it’s not the biblical story. At Babel, the loss of common language stops construction whereas in AI-assisted engineering, construction can continue after shared understanding has already collapsed. The lack of an immediate failure is what makes it curious and a bit disorienting. The tower does not fall, and so we do not notice what was lost. It just keeps rising.
I don't know whether the author thinks this is a good or a bad thing, but in my eyes it's clearly a bad thing. Intelligence is knowing that a tomato is a fruit, wisdom is knowing not to put it in a fruit salad. AI is the the ultimate form of intelligence with zero wisdom. Actually, it's not even intelligence, it's an illusion of intelligence. If there is no human who can understand what the AI is doing it's time to stop and accept that we do not have the wisdom to contain what we are building.
The core thesis of this essay is reminiscent of the Lisp Curse [1] / Bipolar Lisp Programmer [2].
It's been a few years since I read these, but if I recall the argument there, it was that Lisp makes it so easy to build stuff and scratch exactly your own itch, that there's no real strong push for lisp programmers to come together and collaborate to build non-trivial and general purpose artifacts. And that is why the landscape of public lisp software is poorer as a result, compared to languages which demand much more effort to get anything substantial done.
Armin seems to be making a very similar point about AI coding.
Au contraire if typescript and rust didn’t steal the whole show it’d be a great time to be a lisp LLM pilot: agents can explain pretty much everything without any confabulations nowadays, so the understanding problem essentially goes away, if you care, which is exactly the point of the article if you ask me.
lisp can do things that make the currently accepted as standard best practice software engineering processes redundant, but it needs a different set of processes which I’m not sure are written about anywhere since apparently nobody is running with e.g. hot patching of application code
> compared to languages which demand much more effort to get anything substantial done.
It is not clear at all to me that other languages "demand much more effort" for the same end result.
It is clear that many non-lisp programmers value syntax, and many lisp programmers don't. Even many people who programmed enough lisp to have their minds blown and expanded still prefer not to program in lisp. I'm still awaiting psychological studies on this, but the rift is so large, I think there may be some significantly different brain processing going on between the two groups.
To your point, yes, it is also clear that, to the extent that lisp can match the productivity of other languages, whether it exceeds them or not, one of the tools that is needed to achieve this productivity boost in lisp is heavy usage of homoiconicity, and this results in every serious lisp program being a collection of DSLs, each of which is only understood by one person or very few people.
> There is the appealing idea that AI-assisted programming means better tools which lets us build more ambitious software. That is certainly true at the level of the individual and without doubt a developer with an agent will be dramatically more capable of changing a codebase. But large software projects have never been limited only by how quickly an individual can produce code. They are limited by how well people can coordinate their understanding of the system they are changing.
So true.
Since Nov 30, 2022 everything has become… more complex.
I feel like with software, things have gotten way too complicated (just layer's upon layers upon layers). But to deal with that complexity, now we're using something that just creates WAY more complexity. I've been coding for a while, and I remember the 90s and early 00s where people could make pretty powerful applications with like visual basic or php with essentially no formal training. Those technologies weren't great, but they were really simple and easy to pick up. In contrast, if you try to pick up web development or desktop app development today, it's absolutely overwhelming. Like, something like React is useful but the amount of things you need to know to use it properly is pretty high.
I think introducing AI to deal with this is overall a mistake though. We're just adding more complexity on top of the existing complexity. At best, it's a massive waste of hardware. At worst, we'll probably have agents introducing as many bugs as they fix as they also drown in complexity, and a lot of stuff built using these techniques are going to be fragile garbage while the overall skillset of humanity diminishes because people aren't learning the skills anymore.
Fundamentally, software does not need to be this complicated and it's a solvable problem, but it does require people that care about craftsmanship.
I had a discussion with folks at work about what information is worth retaining in the face of AI doing everything for us. A lot of what we have in our heads to qualify as "domain experts" is pretty esoteric. How to invoke command line tools, gotchas because library A uses one convention over library B, AWS vs GCP; so much is specific to a tool rather than a method. There are also a lot of entrenched tools that are effectively unfixable due to the risk of breaking changes, so you have to shrug and accept + learn that's how it works.
Catch-22 is it's still important to know the fundamentals so you know what to ask for, but if you don't know the esoterica, the model is eventually going to make an assumption and screw things up. And the models don't have much taste either in prose, or in coding/comment style.
And what's ironic is that a lot of those layers and complexity were added with the stated goal of making it easier for average developers to build applications.
> They are limited by how well people can coordinate their understanding of the system they are changing.
It's not really news, though. Programming as Theory Building (Peter Naur) was published in the 80s, I think?
Maybe the younger entrants to this field never came across it, but even if you never came across it, it was common knowledge amongst experienced devs that understanding of the system you are about to change is crucial.
The complexity of coordinating a project involving more than one entity is, of course, an issue across all industrial sectors—just look at the construction industry.
Thanks for mentioning Peter Naur’s Programming as Theory Building (1985).
I would add Fred Brooks and his The Mythical Man-Month.
I don't know. some stuff has gotten less. Major databases now ship effective HA tooling, microservices seem on their way out, structured databases seem to be back in instead of NoSQL.
HTML and pre-rendering are back in, HTMx, liveview
The degaussing of CSS and the hacks we did, hell i was trying to explain how we debugged web pages in IE6 to a younger staff member today.
Some things are more complex, some things got good enough to make them less complex.
>Since Nov 30, 2022 BC everything has become… more complex.
FTFY
Increasing complexity is the story of mankind. It's the story of civilization.
Someone from 20,000 BC would wander around the earth trying to find food, trying not to freeze, and trying not to get eaten. Someone from 5,000 BC would be trying to grow food, hoping it rains, and hoping disease didn't wipe out the village. The second one increases the complexity from all the systems required to manage people and keep the land growing. Today the vast majority of people on earth don't grow their own food at all, and instead are busy in some way managing the complexity of a large society.
Someone from 1970-80 would think our software from pre-llm days was vastly more complex. They'd just code directly to the hardware with no abstraction layer. Now almost no one does that. We abstracted the hardware away in most cases. With cryptography libraries for the vast majority of people it's complexity is abstracted away and mostly people are told "don't try to write your own crypto because you will fuck it up".
The question now becomes, how quickly will LLMs be able to coordinate their understanding of the system they are changing?
Then I think you should check in with your favorite mental health provider before you become a danger to yourself or others.
Simply put LLMs do understand some things within their crystalized intelligence. Your anthropocentric mind may not accept this, but one day it will. As LLMs have a very short context window in relation to their stored knowledge they have very limited plastic intelligence to change their minds or adapt. All of which is flushed away at the end of a session. It would be like living without the ability to turn your short term memory into new long term memories.
I would gladly use another word for what LLMs can do, but the world at large has not adopted any. The definitions we use around intelligence, comprehension, understanding, consciousness, and sapitence have already been failing us for some time before LLMs as our scientific understanding of biology has increased over the decades as it is. I am one for more exacting definitions when they exist, but humans seem to barely understand the inner workings of our own minds, in large such words escape us.
I'll meet you in the middle: an LLM "understands" words in the same way a toddler understands the phrases they say. "My want cookie!" The toddler has zero comprehension of what any of those words mean, but they know that saying them in that order might result in something desirable.
An LLM has zero understanding of "my", "want", or "cookie" because an LLM has no id/ego, has never felt desire, and has never eaten a cookie.
I believe you've made a category error in understanding, um, understanding. You've tied emotion into it. This to me are entirely different concepts where both happen to be wrapped up in meaty flesh that drives us humans. Now, these concepts are very important in sociology and human understanding of how we behave, but they also may have zero importance for the domain that encompases all understanding.
HN would commonly recommend reading the book Blindsight here.
Moreso, all you've done is recreate the Searle Chinese Room thought experiment which gets bounced around with no means of deciding if it reflects reality or not.
> The shared language of a software project is not English or Python but it is the common understanding of what its concepts mean, where the boundaries are, which invariants matter, who owns what, and why the system has the shape it does. This language is rarely written down in one place. It lives partly in documentation and code, but also in code review, conversations, arguments, and the experience of having to explain a change to somebody else.
This is so true. I am a big fan of Christopher Alexander’s “Pattern Language” concept, which addresses this exact problem! In fact he recommends developing your own pattern languages for your own domains (which of course led to the famous GoF Design Patterns book).
I have been experimenting with a “Pattern Language” skill which instructs the AI to maintain 3 pattern languages for every project. One in the business domain, one in the product domain, and one in the technical domain. It is working really well. It is always super cool to see it reference the pattern languages during planning and curate them during implementation and review.
I credit using it with keeping my 100% ai-coded projects well organized, aligned across domains, and easy to work on.
If humans are still around by the end of the century: previously shunned philosophical movements such as pragmatism will actually become mainstream again.
The most interesting problems arise when you don't try and force one shared standard upon everybody yet still try and play nice.
Alternatively, power could concentrate and the winners get to decide what is valuable and not, thus cutting down the space of possible complexity by construction.
I come back to Babel and the Bruegel image too, although taking from it a little less optimism.
I feel these systems rising and sprawling with wee myopic agents developing out their little corners of this unknowably vast whole… a tower with 50 parapets on one side and some wacky cantilevered maiden tower on the other, and a very serviceable adobe roof over some patio for god-knows-why, and thatch over the landing next to it…
Some grotesque fatberg of designs that make sense at the level of individual design efforts, but that lack the fractal sort of levels of policy and judgment that unify the overall enterprise.
The overall language, as it were.
And language takes discipline to establish and maintain through any sufficiently large group of people—witness the company-speak or army-speak of pretty much any successful organization.
We feel like we’ve conquered the problem of talking the same language as our “Gastown Mayors” (who in turn are talking the same language as their “polecats” and so on all the way down the chain of golems)… but it’s only when it’s all built that the good Lord will humble us… that we’ll realize the understanding we thought we’d transmitted perfectly from our thrones wasn’t quite so shared as we’d imagined.
My comment is not directly responding to the essay, but it got me thinking about about how agentic programming is much more akin to management than it is to actual programming. Managers generally only have a high level idea of what ICs are working on and often don't have the time, bandwidth, and in some cases ability to understand everything the ICs they're supervising are doing. As more and more software gets written agentically the role of software engineer becomes less technical and more managerial.
It feels to me like I'm stuck doing code reviews for a junior dev all day so I use it as little as possible and mostly to look for things I may have missed.
For example, yesterday I came across some unit tests that didn't have error messages in their assertions. Normally, it takes me ~10 minutes to fix a handful of tests in this situation. In this case, I gave a 2-3 sentence prompt, went to the bathroom, and reviewed the result after I washed my hands. Saved me a bunch of time!
I encourage you to accept a feeling of "imposter syndrome" when using it, and keep trying new things with it. Don't feel like you have to be hands off, except when you're confident that you can be. (IE, if you think you need to spend 30+ minutes on mindless refactoring, see if you can explain it to an agent and then look at HN while it runs. You might get a good result, otherwise, it probably was time for a break anyway.)
BTW: It's important to try different models. The Claude 5.0 models are slow and give me bad results, so I'm sticking with 4.x for now.
It used to be that you need a good reason to make huge refactorings, because it’s often so much work. Now agent can rewrite half of your code if your prompt is vague enough and you don’t actual try to review it all. And so the “soul” of a program can change dramatically every single day. It’s both great and very much not so.
The biggest obstacle to huge refactoring has always been minimizing the risk of bugs, not losing any features, and ensuring compatibility with the existing ecosystem. The reason it's become easier in the age of AI is because we stopped caring about these things.
Yep. That’s what people are forgetting. If you have an application that many people depend on to do real work, to make money, you won’t survive if you allow AI to constantly make huge changes.
Your test suite doesn’t cover all workflows. It doesn’t cover every combination of actions a user can take. So every big AI refactor while change some of those.
If this is happening frequently, your software will feel like a janky piece of unusable crap.
Apple AirPods and Google buds both can do automatic translation. It's still a little too slow and is a little clumsy to use but it's getting better fast.
> I can ask an agent to add OAuth, you can ask one to add caching, and somebody else can ask one to rebuild the database from first principles and make the UI pink. Each change can be reasonable in isolation.
But this is just bad vibecoding? This would be bad if humans did it too. With agents or humans, you need to coordinate.
The agent will always fill in the gaps in your understanding. It's not a compiler. It's categorically different from any of the other ways we've built software.
I'm not sure reading code is coming back. The ritual of reading code must come back, because that's the only way to build products that don't collapse under their own incoherence, both technically and visibly.
"just ask Claude" is fine, but it's not the end state
Three or so years ago, Omar, the creator of DSpy pointed out on Twitter that ~LLMs get better most by better internal collaboration. Wish I could find it.
It seems to me that LLMs and particularly chatbots have already allowed for bigger scale collaboration within the LLM companies versus what was possible within the prior cohort of big platform companies.
Has the result just been taller towers, or actually a change of what is possible?
I interpret "keeps rising" negatively. Changes keep getting made, certainly. The AIs will perhaps never fail to fulfill your feature request. But there's no overall plan. It's just undirected, cancerous growth. It's Homer Simpson telling a team of automotive engineers to add feature after feature.
This isn't really a good way to judge things. In the future, the fondest memories someone else has about technology will be about the present. The past is not better, you're just nostalgic for it.
Every time I think the past was better, I think about how terrible ksh scripting was in 1995. And look at how great peoples' bash scripting is now compared to when we though bash had reached its apex in like 2009.
Is growth enough if technology makes our lives worse? Is a tower the pride of the civilization if a strong gust of wind could bring it down? It is before the gust, when all that matters is that the tower is tall rather than strong. After the gust, things are a bit more nuanced. Fingers are pointed.
The tricky part here is that you can't tell if a once-topmost part of the tower is sturdy until a great deal more tower is resting on it. Well, now a lot the economy is resting on little other than AI dreams. Your move, rational people.
I don't know why people hold on to all this extra software and features when with the tools its easier than ever to strip that out and refactor the end product in to a much more compact deliverable. Maybe once upon a time it was useful to keep legacy parts of the software solution around, but it can be recreated with fresh eyes if needed given the power of the new LLM models. My philosophy is if its not needed, it needs to be removed.
AI replaces a single tower with millions of 5-over-1s[1]. The aggregate height, and speed of construction mind-boggling, but when each building is considered individually, not very impressive.
1. Perhaps with a handful of skyscrapers sprinkled in.
so the post-AI landscape is software as a shanty town? That's not a bad analogy. We won't like the looks of it and it will barely function but like real life shanty towns it will function nonetheless.
This is exactly what Marx meant by labourers being alienated from their work because none of them understood anymore how the repetitive task they did factored into the product sold.
We are going through a transition from a guild based software production with primitive division of labour to a machinery based one where AI is the steam engine and the job of the engineer is to build the production line, be the mechanic fixing the line, and also the assembly line worker.
at one point - future generations - will look at people who designed unix like tools - tools that do one thing well & compose with other tools as demigods.
Since GPT 5.2, AI has been writing code much better than I can. In 5.6, it beat Tourlist in competitive coding. After seeing that, I only practice about an hour a day just to keep the feel of coding.
Honestly, rather than pointless debates about whether human coding is bad or AI coding is bad, I just think it's good to build tools that help me understand the world. I don't really care whether it's hand-coded or bad code.
Because most of my career has been spent as an on-site programmer. Staying at factories, visiting public institutions, deploying services for financial companies. My career is short, but I was lucky enough to work in various places.
When AI first came out, I thought I still wrote better code. But after the GPT 5 series, I've completely switched to AI and I'm now thinking about how to avoid errors and maintain larger codebases.
In the world I work in, it's common to see functions with 10,000 lines. Many people don't consider coupling or cohesion. So these days, instead of focusing on programming syntax, I'm studying programming theory and thinking about how to handle code when it becomes massive and turns into a black box through vibe coding. And I think this approach is right, because I believe I need to get used to using AI, so I keep coding with it.
But due to my cognitive limits, I've restricted myself to C# and TypeScript, which I'm comfortable with. C++ has too much to memorize and is hard to keep up with. In my region, there are very few C++ jobs, and those that exist are either extremely high-paying or garbage-tier jobs. There's nothing in between. So I stick with C# and TypeScript.
In practice, when building large programs, I often just set external configuration values I don't fully understand and code based on heuristics. I don't know the internals of Kafka, RabbitMQ, or PostgreSQL. I just know how to use them. And yet they work fine.
I feel the same way about AI code. Even if AI code is messy, if it runs, I use it. When bugs appear or performance is off, I just plug in debuggers or print statements and fix the necessary parts, like working with legacy code. Programming is so complex that if you try to understand everything, you can only design very small parts. Do the people who wrote Linux understand the entire codebase? They trust people they can rely on.
I've also reached an internal agreement to trust AI code. To support that, I'm spending time on creating rules for how to get good code from AI. Things like adding gates or CI, and seeing if that improves the code.
The problem is, I know this means no one will want to use other people's work or collaborate. The middle layer will disappear. There will be only highly admired projects or personal projects. In the past, even mid-sized projects had humans helping each other. But now mid-sized projects barely need human help. So I think projects will become increasingly polarized and become a zero-sum game.
Brooks divided complexity into two types in The Mythical Man-Month: Essential Complexity and Accidental Complexity. Personally, I think AI has greatly reduced Accidental Complexity. However, the essential difficulty, the problem of modeling, still needs to be done by humans. Because AI has no physical embodiment, it's inherently hard for it to understand domains the way humans do. Learning about something is different from experiencing it.
So I've decided to believe that vibe coding is also a valid approach. Supporters talk about compilers being deterministic, but LLMs are not deterministic. Critics say AI only produces garbage code, but I've seen that with high-quality prompts, the output becomes much better. Math PhDs say AI is good at things like theorem proving, and most of coding is similar to theorem proving.
It's not about good or bad. I've decided to believe it's just another approach. Yes, this is just a religion. My religion.
No matter how much people say vibe coding is bad, those who use it well do use it well. And there's no reason to criticize those who don't use it. I've just decided to treat this programming approach as a religion. Arguing about what's right or wrong is pointless anyway. Everyone has different values based on their environment, and convincing others is a waste of time.
People in open source communities might feel like AI code is destroying their communities. The code they used to communicate with, and the time they spent on it.
But for someone like me, who's been in delivery and on-site work, it feels like an escape hatch. It freed me from the hell of dealing with difficult people. So I've decided to rationalize it to myself: AI coding is just one way of doing things
I just think new methodologies will emerge. Instead of dividing code by functions or methods, people will think about how to divide things at a larger scale.
I'm just living to adapt to this era. I have nothing to lose anyway. I'm just waiting for the new era.
You use a shared agents.md and an auto updated architecture doc but that is the one that needs to be heavily scrutinized and everyone gets a turn to review it.
this doesn't work in any truly complex system. If the entire organization's shared understanding could be captured in a few documents, software engineering would've been a solved problem ages ago.
I've said for a long time that composability in software is a bit like playing Tetris: the lines have to clear.
I feel like that gives an even more literal tower-rising metaphor, and that's what it feels like people using agents naively (and software engineers of lower skill or earlier-career), end up violating.
Agents are getting better at folding things into themselves, especially if you direct them to... but unfortunately I've found that the architectural instincts, even of Fable and 5.6 Sol, are still wildly behind what I reflexively achieve, say.
For sure there is an ability to have agents go back over work and try to fold it into better and better abstractions until it's sort of annealed into something good. I've done something similar on codebases that I have, but the 'high reaches' of architecture with great _prediction of how the software will evolve in the future_ in _subtle_ ways – those are, for now, out of reach of agents.
There is a part of me that wonders if it's partly just how much they can hold in their head right now, though. Even with the greatest articulation and high density of feeding them, the current setups don't allow them to hold a high-quality, sparse, 'zoomable' model of the world in their head that well yet, which we can do pretty well.
But the fact that I'm talking about it in terms of that kind of subtlety is itself promising, I guess?
The upper bound on program complexity used to be the power of the human mind. "Vibe coding" can break through that barrier. But not because the problem being solved needs that complexity. Because the process does not drive itself towards compact abstractions. It's the AI-powered version of the scaling problem Brooks described back in "The Mythical Man-Month". The combinatoric problems get worse with scale. Concretely, multiple similar implementations of roughly the same thing appear in different parts of the project. This is a known problem of vibe coding now.
We need some way to make AI-driven coding strive for parsimony.
Why would it? It has optimized what it was built to optimize: this is the token-selling industry. Take note that the people hawking the dream of a gold rush are not actually mining but selling shovels
Same issue happens in models trained by organizations who aren’t selling tokens. I believe it’s because being parsimonious is simply harder. Achieving the task at hand independently and declaring the job done is easier than building an abstraction and reconciling between every use case.
Labs are trying to make long-horizon work. Even if you're a coding agent, adding more and more surface area is distracting to that goal. There is reason that RL over long traces should, at least in principle, optimize for building in ways that help the result fit in the model's context window.
A meaningful risk of course is that the tools available to the model (ripgrep + fancier semantic approaches) allow it to do a good job of reasoning over things much larger than its context window, and so it doesn't pay the penalty sufficiently to fix it.
Does that not sound a little silly to you when you say it? Should I invest in becoming a memory athlete as a way of becoming a better software engineer? ...or should I learn how to build and use tools?
> "Vibe coding" can break through that barrier. But not because the problem being solved needs that complexity. Because the process does not drive itself towards compact abstractions.
It's the infinite AI monkeys at a computer keyboard phenomenon.
Or the car on the highway that bumps left and right on the guardrails until, eventually, it arrives at its destination and nearly everybody is amazed at that great success.
The AI kool-aid drinkers are going to answer: "but that's how human code too".
And I'm really not sure about that.
It's perhaps how some humans code but frankly if you have those people employed to build software for you, you have big problems
Isn't this just an effect of what the LLMs are RL'ed for? Solving short-horizon tasks.
I assume one can't benchmaxx multi-year long efforts, clean architecture, taste etc as easily as these "make tests pass" tasks
> the lines have to clear.
Sorry, the lines have to clear what? Surely there must be some kind of constraint on "lines" that they have to overcome.
The lines (rows) in Tetris have to become complete and then disappear to make room for the new falling pieces.
In code the thing has to become stable, can't just keep packing more and more noise onto it.
Absolutely this: and it needs to ideally become the kind of set of abstractions that mean that every new thing added uses less net-new surface area than it would without them.
I mean that at the bottom of the Tetris board, the lines need to vanish so that the Tetris board keeps moving downward and doesn't grow unbounded.
Do you believe "micro services" can make a comeback? local daemons with an exposed API, each daemon vibe coded?
Microservices are about separate deployment. Regarding separating the development/maintenance of components, you can achieve that in a monolith by composing it out of corresponding modules/libraries with defined APIs. That’s good practice anyway.
Unless we are planning to deploy them all individually to an expensive serverless platform like Lambda, the coordination challenges and overprovisioning are going to more than outweigh whatever architectural benefit you reap (in human-centred development, micro services are solving an entirely different problem - Conway's Law)
Microservices don’t reduce complexity, they just move it to the interactions between services. You have the same fundamental design problem.
In other words, if you can’t design a modular monolith, you can’t design a set of microservices.
Sure, why not? The same reasons they succeeded originally will work just as fine now.
Please no.
Lemme guess, you were in favour of monolithic systemd too?
Agreed, and ever since LLMs started being able to write competent code, I've noticed a massive difference in quality on codebases where I knew the technology, and ones I didn't. This is because I can much more efficiently steer the LLM on e.g. backend code, which is my expertise, vs yoloing everything on mobile, where I have no idea.
The codebases using technologies I have no idea about tend to quickly become unmaintainable and buggy, because the LLM still doesn't make good architectural choices, but the codebases that use technologies I'm familiar with basically never devolve into unmaintainability.
The difference between the two is massive, and that's why I think that a competent engineer steering an LLM in their area of expertise gets two orders of magnitude more productive, whereas someone steering an LLM in an area they know nothing about are basically producing tech debt at the speed of thought.
> two orders of magnitude more productive
Shipping 100x more features per day?
Yes.
> But it’s not the biblical story. At Babel, the loss of common language stops construction whereas in AI-assisted engineering, construction can continue after shared understanding has already collapsed. The lack of an immediate failure is what makes it curious and a bit disorienting. The tower does not fall, and so we do not notice what was lost. It just keeps rising.
I don't know whether the author thinks this is a good or a bad thing, but in my eyes it's clearly a bad thing. Intelligence is knowing that a tomato is a fruit, wisdom is knowing not to put it in a fruit salad. AI is the the ultimate form of intelligence with zero wisdom. Actually, it's not even intelligence, it's an illusion of intelligence. If there is no human who can understand what the AI is doing it's time to stop and accept that we do not have the wisdom to contain what we are building.
The core thesis of this essay is reminiscent of the Lisp Curse [1] / Bipolar Lisp Programmer [2].
It's been a few years since I read these, but if I recall the argument there, it was that Lisp makes it so easy to build stuff and scratch exactly your own itch, that there's no real strong push for lisp programmers to come together and collaborate to build non-trivial and general purpose artifacts. And that is why the landscape of public lisp software is poorer as a result, compared to languages which demand much more effort to get anything substantial done.
Armin seems to be making a very similar point about AI coding.
[1] https://www.winestockwebdesign.com/Essays/Lisp_Curse.html
[2] https://www.marktarver.com/bipolar.html
Au contraire if typescript and rust didn’t steal the whole show it’d be a great time to be a lisp LLM pilot: agents can explain pretty much everything without any confabulations nowadays, so the understanding problem essentially goes away, if you care, which is exactly the point of the article if you ask me.
But at that point why use Lisp (which LLMs have been so far still to struggle to get matching parens every now and then)
What made Lisp cool and powerful goes away when you do it through an LLM.
lisp can do things that make the currently accepted as standard best practice software engineering processes redundant, but it needs a different set of processes which I’m not sure are written about anywhere since apparently nobody is running with e.g. hot patching of application code
> compared to languages which demand much more effort to get anything substantial done.
It is not clear at all to me that other languages "demand much more effort" for the same end result.
It is clear that many non-lisp programmers value syntax, and many lisp programmers don't. Even many people who programmed enough lisp to have their minds blown and expanded still prefer not to program in lisp. I'm still awaiting psychological studies on this, but the rift is so large, I think there may be some significantly different brain processing going on between the two groups.
To your point, yes, it is also clear that, to the extent that lisp can match the productivity of other languages, whether it exceeds them or not, one of the tools that is needed to achieve this productivity boost in lisp is heavy usage of homoiconicity, and this results in every serious lisp program being a collection of DSLs, each of which is only understood by one person or very few people.
> There is the appealing idea that AI-assisted programming means better tools which lets us build more ambitious software. That is certainly true at the level of the individual and without doubt a developer with an agent will be dramatically more capable of changing a codebase. But large software projects have never been limited only by how quickly an individual can produce code. They are limited by how well people can coordinate their understanding of the system they are changing.
So true.
Since Nov 30, 2022 everything has become… more complex.
I feel like with software, things have gotten way too complicated (just layer's upon layers upon layers). But to deal with that complexity, now we're using something that just creates WAY more complexity. I've been coding for a while, and I remember the 90s and early 00s where people could make pretty powerful applications with like visual basic or php with essentially no formal training. Those technologies weren't great, but they were really simple and easy to pick up. In contrast, if you try to pick up web development or desktop app development today, it's absolutely overwhelming. Like, something like React is useful but the amount of things you need to know to use it properly is pretty high.
I think introducing AI to deal with this is overall a mistake though. We're just adding more complexity on top of the existing complexity. At best, it's a massive waste of hardware. At worst, we'll probably have agents introducing as many bugs as they fix as they also drown in complexity, and a lot of stuff built using these techniques are going to be fragile garbage while the overall skillset of humanity diminishes because people aren't learning the skills anymore.
Fundamentally, software does not need to be this complicated and it's a solvable problem, but it does require people that care about craftsmanship.
I had a discussion with folks at work about what information is worth retaining in the face of AI doing everything for us. A lot of what we have in our heads to qualify as "domain experts" is pretty esoteric. How to invoke command line tools, gotchas because library A uses one convention over library B, AWS vs GCP; so much is specific to a tool rather than a method. There are also a lot of entrenched tools that are effectively unfixable due to the risk of breaking changes, so you have to shrug and accept + learn that's how it works.
Catch-22 is it's still important to know the fundamentals so you know what to ask for, but if you don't know the esoterica, the model is eventually going to make an assumption and screw things up. And the models don't have much taste either in prose, or in coding/comment style.
And what's ironic is that a lot of those layers and complexity were added with the stated goal of making it easier for average developers to build applications.
Amen.
Drowning in complexity. Paralysis of choice.
I read a comment (joke) that if you want to follow all LLM development you should have to be unemployed.
> They are limited by how well people can coordinate their understanding of the system they are changing.
It's not really news, though. Programming as Theory Building (Peter Naur) was published in the 80s, I think?
Maybe the younger entrants to this field never came across it, but even if you never came across it, it was common knowledge amongst experienced devs that understanding of the system you are about to change is crucial.
The complexity of coordinating a project involving more than one entity is, of course, an issue across all industrial sectors—just look at the construction industry.
Thanks for mentioning Peter Naur’s Programming as Theory Building (1985).
I would add Fred Brooks and his The Mythical Man-Month.
> It's not really news, though. Programming as Theory Building (Peter Naur) was published in the 80s, I think?
The news is that Agentic Programming has made this always challenging task even more challenging.
I don't know. some stuff has gotten less. Major databases now ship effective HA tooling, microservices seem on their way out, structured databases seem to be back in instead of NoSQL.
HTML and pre-rendering are back in, HTMx, liveview
The degaussing of CSS and the hacks we did, hell i was trying to explain how we debugged web pages in IE6 to a younger staff member today.
Some things are more complex, some things got good enough to make them less complex.
A database with built-in HA is a significantly more complex system than one without it.
And one built without it and not coordinating with it is often much harder to reason about when you bolt it on later.
> Major databases now ship effective HA tooling
Which ones? PostgreSQL doesn't have HA in core.
MySQL 8, but upon review that was 2018. 5.7 had some but it's certainly improved overall since then as well
>Since Nov 30, 2022 BC everything has become… more complex.
FTFY
Increasing complexity is the story of mankind. It's the story of civilization.
Someone from 20,000 BC would wander around the earth trying to find food, trying not to freeze, and trying not to get eaten. Someone from 5,000 BC would be trying to grow food, hoping it rains, and hoping disease didn't wipe out the village. The second one increases the complexity from all the systems required to manage people and keep the land growing. Today the vast majority of people on earth don't grow their own food at all, and instead are busy in some way managing the complexity of a large society.
Someone from 1970-80 would think our software from pre-llm days was vastly more complex. They'd just code directly to the hardware with no abstraction layer. Now almost no one does that. We abstracted the hardware away in most cases. With cryptography libraries for the vast majority of people it's complexity is abstracted away and mostly people are told "don't try to write your own crypto because you will fuck it up".
The question now becomes, how quickly will LLMs be able to coordinate their understanding of the system they are changing?
>LLMs be able to coordinate their understanding
I think the next time I see "LLMs" and "Understanding" in the same sentence, I am going to lose it....
>I am going to lose it
Then I think you should check in with your favorite mental health provider before you become a danger to yourself or others.
Simply put LLMs do understand some things within their crystalized intelligence. Your anthropocentric mind may not accept this, but one day it will. As LLMs have a very short context window in relation to their stored knowledge they have very limited plastic intelligence to change their minds or adapt. All of which is flushed away at the end of a session. It would be like living without the ability to turn your short term memory into new long term memories.
I would gladly use another word for what LLMs can do, but the world at large has not adopted any. The definitions we use around intelligence, comprehension, understanding, consciousness, and sapitence have already been failing us for some time before LLMs as our scientific understanding of biology has increased over the decades as it is. I am one for more exacting definitions when they exist, but humans seem to barely understand the inner workings of our own minds, in large such words escape us.
I'll meet you in the middle: an LLM "understands" words in the same way a toddler understands the phrases they say. "My want cookie!" The toddler has zero comprehension of what any of those words mean, but they know that saying them in that order might result in something desirable.
An LLM has zero understanding of "my", "want", or "cookie" because an LLM has no id/ego, has never felt desire, and has never eaten a cookie.
I believe you've made a category error in understanding, um, understanding. You've tied emotion into it. This to me are entirely different concepts where both happen to be wrapped up in meaty flesh that drives us humans. Now, these concepts are very important in sociology and human understanding of how we behave, but they also may have zero importance for the domain that encompases all understanding.
HN would commonly recommend reading the book Blindsight here.
Moreso, all you've done is recreate the Searle Chinese Room thought experiment which gets bounced around with no means of deciding if it reflects reality or not.
I'll meet you in the middle: an LLM "understands" words in the same way a toddler understands the phrases they say.
How'd your toddler do at IMO last year?
You should be less upset over semantics that everyone else has usefully settled on. LLMs understand things fine.
> IBM has entered the chat
https://en.wikipedia.org/wiki/VM_(operating_system)
> The shared language of a software project is not English or Python but it is the common understanding of what its concepts mean, where the boundaries are, which invariants matter, who owns what, and why the system has the shape it does. This language is rarely written down in one place. It lives partly in documentation and code, but also in code review, conversations, arguments, and the experience of having to explain a change to somebody else.
This is so true. I am a big fan of Christopher Alexander’s “Pattern Language” concept, which addresses this exact problem! In fact he recommends developing your own pattern languages for your own domains (which of course led to the famous GoF Design Patterns book).
I have been experimenting with a “Pattern Language” skill which instructs the AI to maintain 3 pattern languages for every project. One in the business domain, one in the product domain, and one in the technical domain. It is working really well. It is always super cool to see it reference the pattern languages during planning and curate them during implementation and review.
I credit using it with keeping my 100% ai-coded projects well organized, aligned across domains, and easy to work on.
Do you have any github examples publically available?
If humans are still around by the end of the century: previously shunned philosophical movements such as pragmatism will actually become mainstream again.
The most interesting problems arise when you don't try and force one shared standard upon everybody yet still try and play nice.
Alternatively, power could concentrate and the winners get to decide what is valuable and not, thus cutting down the space of possible complexity by construction.
Anakin: "a developer with an agent will be dramatically more capable of changing a codebase"
Padmé: "For the better, right?"
Anakin: (gazes in silence)
Padmé: "For the better, right?"
https://www.newyorker.com/cartoons/daily-cartoon/monday-july...
I come back to Babel and the Bruegel image too, although taking from it a little less optimism.
I feel these systems rising and sprawling with wee myopic agents developing out their little corners of this unknowably vast whole… a tower with 50 parapets on one side and some wacky cantilevered maiden tower on the other, and a very serviceable adobe roof over some patio for god-knows-why, and thatch over the landing next to it…
Some grotesque fatberg of designs that make sense at the level of individual design efforts, but that lack the fractal sort of levels of policy and judgment that unify the overall enterprise.
The overall language, as it were.
And language takes discipline to establish and maintain through any sufficiently large group of people—witness the company-speak or army-speak of pretty much any successful organization.
We feel like we’ve conquered the problem of talking the same language as our “Gastown Mayors” (who in turn are talking the same language as their “polecats” and so on all the way down the chain of golems)… but it’s only when it’s all built that the good Lord will humble us… that we’ll realize the understanding we thought we’d transmitted perfectly from our thrones wasn’t quite so shared as we’d imagined.
My comment is not directly responding to the essay, but it got me thinking about about how agentic programming is much more akin to management than it is to actual programming. Managers generally only have a high level idea of what ICs are working on and often don't have the time, bandwidth, and in some cases ability to understand everything the ICs they're supervising are doing. As more and more software gets written agentically the role of software engineer becomes less technical and more managerial.
It feels to me like I'm stuck doing code reviews for a junior dev all day so I use it as little as possible and mostly to look for things I may have missed.
It's great for "mechanical" changes.
For example, yesterday I came across some unit tests that didn't have error messages in their assertions. Normally, it takes me ~10 minutes to fix a handful of tests in this situation. In this case, I gave a 2-3 sentence prompt, went to the bathroom, and reviewed the result after I washed my hands. Saved me a bunch of time!
I encourage you to accept a feeling of "imposter syndrome" when using it, and keep trying new things with it. Don't feel like you have to be hands off, except when you're confident that you can be. (IE, if you think you need to spend 30+ minutes on mindless refactoring, see if you can explain it to an agent and then look at HN while it runs. You might get a good result, otherwise, it probably was time for a break anyway.)
BTW: It's important to try different models. The Claude 5.0 models are slow and give me bad results, so I'm sticking with 4.x for now.
Use the force Luke!
I finally learned to let go of the code. I dont even run my C++ editor anymore.
I run frequent code and architectural reviews. Its awesome.
the tower keeps rising but the elevator pitch for every new floor is 'it solves the problems created by the floor below it'
It used to be that you need a good reason to make huge refactorings, because it’s often so much work. Now agent can rewrite half of your code if your prompt is vague enough and you don’t actual try to review it all. And so the “soul” of a program can change dramatically every single day. It’s both great and very much not so.
The biggest obstacle to huge refactoring has always been minimizing the risk of bugs, not losing any features, and ensuring compatibility with the existing ecosystem. The reason it's become easier in the age of AI is because we stopped caring about these things.
Yep. That’s what people are forgetting. If you have an application that many people depend on to do real work, to make money, you won’t survive if you allow AI to constantly make huge changes.
Your test suite doesn’t cover all workflows. It doesn’t cover every combination of actions a user can take. So every big AI refactor while change some of those.
If this is happening frequently, your software will feel like a janky piece of unusable crap.
Douglas Adams basically predicted Wikipedia on smartphones, and I suspect we are only a few years away from babelfish ear buds.
Apple AirPods and Google buds both can do automatic translation. It's still a little too slow and is a little clumsy to use but it's getting better fast.
> I can ask an agent to add OAuth, you can ask one to add caching, and somebody else can ask one to rebuild the database from first principles and make the UI pink. Each change can be reasonable in isolation.
But this is just bad vibecoding? This would be bad if humans did it too. With agents or humans, you need to coordinate.
The agent will always fill in the gaps in your understanding. It's not a compiler. It's categorically different from any of the other ways we've built software.
I'm not sure reading code is coming back. The ritual of reading code must come back, because that's the only way to build products that don't collapse under their own incoherence, both technically and visibly.
"just ask Claude" is fine, but it's not the end state
Three or so years ago, Omar, the creator of DSpy pointed out on Twitter that ~LLMs get better most by better internal collaboration. Wish I could find it.
It seems to me that LLMs and particularly chatbots have already allowed for bigger scale collaboration within the LLM companies versus what was possible within the prior cohort of big platform companies.
Has the result just been taller towers, or actually a change of what is possible?
Does it really keep rising? Many of my fondest memories of technology come from times past...
I interpret "keeps rising" negatively. Changes keep getting made, certainly. The AIs will perhaps never fail to fulfill your feature request. But there's no overall plan. It's just undirected, cancerous growth. It's Homer Simpson telling a team of automotive engineers to add feature after feature.
This isn't really a good way to judge things. In the future, the fondest memories someone else has about technology will be about the present. The past is not better, you're just nostalgic for it.
Every time I think the past was better, I think about how terrible ksh scripting was in 1995. And look at how great peoples' bash scripting is now compared to when we though bash had reached its apex in like 2009.
> Many of my fondest memories of technology come from times past...
Is that because of the technology or because of who you were at the time?
The tower is not about fondness, its about growth
Is growth enough if technology makes our lives worse? Is a tower the pride of the civilization if a strong gust of wind could bring it down? It is before the gust, when all that matters is that the tower is tall rather than strong. After the gust, things are a bit more nuanced. Fingers are pointed.
The tricky part here is that you can't tell if a once-topmost part of the tower is sturdy until a great deal more tower is resting on it. Well, now a lot the economy is resting on little other than AI dreams. Your move, rational people.
I don't know why people hold on to all this extra software and features when with the tools its easier than ever to strip that out and refactor the end product in to a much more compact deliverable. Maybe once upon a time it was useful to keep legacy parts of the software solution around, but it can be recreated with fresh eyes if needed given the power of the new LLM models. My philosophy is if its not needed, it needs to be removed.
AI replaces a single tower with millions of 5-over-1s[1]. The aggregate height, and speed of construction mind-boggling, but when each building is considered individually, not very impressive.
1. Perhaps with a handful of skyscrapers sprinkled in.
so the post-AI landscape is software as a shanty town? That's not a bad analogy. We won't like the looks of it and it will barely function but like real life shanty towns it will function nonetheless.
This could've been a much better article without the strained Tower of Babel article.
This reminds me of Ted Chiang's "Tower of Babylon". You really should read it (and all of TC's works)!
> the people is one, ... one language, ..., nothing will be restrained from them
Why being one (I see as collaborative) was it not desired? Interpretations? Why is it seemed *more* harmful rather than good?
This is exactly what Marx meant by labourers being alienated from their work because none of them understood anymore how the repetitive task they did factored into the product sold.
We are going through a transition from a guild based software production with primitive division of labour to a machinery based one where AI is the steam engine and the job of the engineer is to build the production line, be the mechanic fixing the line, and also the assembly line worker.
Agents are very good at making us think the tower is rising, when in fact it is falling beneath our feet.
at one point - future generations - will look at people who designed unix like tools - tools that do one thing well & compose with other tools as demigods.
lol no. They'll "rediscover" it and claim themselves as demigods.
ai eliminating friction is eliminating learning and understanding. this is felt with more severe consequences in K-12 writing and music.
Since GPT 5.2, AI has been writing code much better than I can. In 5.6, it beat Tourlist in competitive coding. After seeing that, I only practice about an hour a day just to keep the feel of coding.
Honestly, rather than pointless debates about whether human coding is bad or AI coding is bad, I just think it's good to build tools that help me understand the world. I don't really care whether it's hand-coded or bad code.
Because most of my career has been spent as an on-site programmer. Staying at factories, visiting public institutions, deploying services for financial companies. My career is short, but I was lucky enough to work in various places.
When AI first came out, I thought I still wrote better code. But after the GPT 5 series, I've completely switched to AI and I'm now thinking about how to avoid errors and maintain larger codebases.
In the world I work in, it's common to see functions with 10,000 lines. Many people don't consider coupling or cohesion. So these days, instead of focusing on programming syntax, I'm studying programming theory and thinking about how to handle code when it becomes massive and turns into a black box through vibe coding. And I think this approach is right, because I believe I need to get used to using AI, so I keep coding with it.
But due to my cognitive limits, I've restricted myself to C# and TypeScript, which I'm comfortable with. C++ has too much to memorize and is hard to keep up with. In my region, there are very few C++ jobs, and those that exist are either extremely high-paying or garbage-tier jobs. There's nothing in between. So I stick with C# and TypeScript.
In practice, when building large programs, I often just set external configuration values I don't fully understand and code based on heuristics. I don't know the internals of Kafka, RabbitMQ, or PostgreSQL. I just know how to use them. And yet they work fine.
I feel the same way about AI code. Even if AI code is messy, if it runs, I use it. When bugs appear or performance is off, I just plug in debuggers or print statements and fix the necessary parts, like working with legacy code. Programming is so complex that if you try to understand everything, you can only design very small parts. Do the people who wrote Linux understand the entire codebase? They trust people they can rely on.
I've also reached an internal agreement to trust AI code. To support that, I'm spending time on creating rules for how to get good code from AI. Things like adding gates or CI, and seeing if that improves the code.
The problem is, I know this means no one will want to use other people's work or collaborate. The middle layer will disappear. There will be only highly admired projects or personal projects. In the past, even mid-sized projects had humans helping each other. But now mid-sized projects barely need human help. So I think projects will become increasingly polarized and become a zero-sum game.
Brooks divided complexity into two types in The Mythical Man-Month: Essential Complexity and Accidental Complexity. Personally, I think AI has greatly reduced Accidental Complexity. However, the essential difficulty, the problem of modeling, still needs to be done by humans. Because AI has no physical embodiment, it's inherently hard for it to understand domains the way humans do. Learning about something is different from experiencing it.
So I've decided to believe that vibe coding is also a valid approach. Supporters talk about compilers being deterministic, but LLMs are not deterministic. Critics say AI only produces garbage code, but I've seen that with high-quality prompts, the output becomes much better. Math PhDs say AI is good at things like theorem proving, and most of coding is similar to theorem proving.
It's not about good or bad. I've decided to believe it's just another approach. Yes, this is just a religion. My religion.
No matter how much people say vibe coding is bad, those who use it well do use it well. And there's no reason to criticize those who don't use it. I've just decided to treat this programming approach as a religion. Arguing about what's right or wrong is pointless anyway. Everyone has different values based on their environment, and convincing others is a waste of time.
People in open source communities might feel like AI code is destroying their communities. The code they used to communicate with, and the time they spent on it.
But for someone like me, who's been in delivery and on-site work, it feels like an escape hatch. It freed me from the hell of dealing with difficult people. So I've decided to rationalize it to myself: AI coding is just one way of doing things
I just think new methodologies will emerge. Instead of dividing code by functions or methods, people will think about how to divide things at a larger scale.
I'm just living to adapt to this era. I have nothing to lose anyway. I'm just waiting for the new era.
I feel like this is missing the ending of "until gravity wins"
No, the story of the tower of Babel was:
"we can, so we should".
It ended badly.
... and narrowing.
Where the "tower" was once a company (or team?) of human devs, it can now be a single dev and their agents.
The right engineer can likely replace non-technical co-founders with a couple LLMs. Geez, I can't wait to write that article...
You use a shared agents.md and an auto updated architecture doc but that is the one that needs to be heavily scrutinized and everyone gets a turn to review it.
this doesn't work in any truly complex system. If the entire organization's shared understanding could be captured in a few documents, software engineering would've been a solved problem ages ago.