Software design is now cheap(dottedmag.net) |
Software design is now cheap(dottedmag.net) |
And I wouldn't write this article 3 months ago. Since then the quality of the output jumped significantly, it is now possible to put the agent into a proper harness (plan/edit/review/test) and the output is good — and if it's not, you discard it and try again, or point out a detail for the next cycle of improvements.
Yes, this requires a lot of forethought to set up, but it works.
I'm not talking only about "web things", I'm working on a project that involves engineering calculations and a lot of optimization of hot paths, both CPU and GPU.
Let’s be honest, how many devs are actually creating something interesting/unique at their work?
Most of the time, our job is just picking the right combination of well-known patterns to make the best possible trade-offs while fulfilling the requirements.
Right. I don't trust LLM's to pick the right pattern. It will pick _a_ pattern and it will mostly sorta fulfill the requirements.
It’s a winner-takes-all market. There are no buyers for off brand Salesforce or Uber.
> …a slightly accelerated
> modeling phase and then
> let them loose on
> the implementation…
_____
MODEL
…
The Verdict: If you provide a clear instruction like "Before you touch the code, read architecture.puml and ensure your changes do not violate the defined inheritance/dependency structure," the agent will be very effective at following it.
If you just "hope" it bears it in mind, it probably won't.
_The agent is a tool, not a mind-reader; it will take the shortest path to a passing test unless you wall that path off with your architectural models_.
…
To make it actually work, you need to turn the UML from a "suggestion" into a "blocker." You should add a section to your AGENTS.md (or CLAUDE.md ) that looks like this:
1. Tool Trigger: By using words like "…"
Why this works:
…
_____
Yeh even if LLMs are 10x better than today you probably still don't want to implement cryptography from scratch, but use a library.
I also like the 3d printing analogy. We will see how good LLMs get, but I will say that a lot of AI coded tools today have the same feeling as 3d printed hardware. If no engineer was involved the software is cheap and breaks under pressure because no one considered the edge cases. It looks good on the surface but if you use it for something serious it does break.
The engineer might still use an LLM/3d printer but where necessary he'll use a metal connection (write code by hand or at least tightly guide the LLM) to make the product sturdy.
You know what would happen if all the people who handwrote and maintained those libraries revoked their code from the training datasets and forbid their use by the models?
:clown face emoji:
This LLM-maxxing is always a myopic one-way argument. The LLMs steal logic from the humans who invent it, then people claim those humans are no longer required. Yet, in the end, it's humans all the way down. It's never not.
The MCP servers combined with agentic search solved this possibility, just this year superseding RAG methods but all techniques have their place. I don't see much of a future for RAG though, given its computational intensity.
Long story short, training and fine tuning is no longer necessary for an LLM to understand the latest libraries, and therefore the "permission" to train would not even be something applicable to debate
it's a fast moving field, best not to have a strong opinion about anything
How would they know what superior code is? They're trained on all code. My expectation and experience has been that they write median code in the best-case scenario (small greenfields projects, deeply specified, etc).
The code is mostly not bad, but most programmers i have worked with write far better code.
I think it's the opposite -- if you have a good way to design your software (e.g., conceptual and modular), LLM will generate the understanding as well. Design does not only mean code architecture, it also means how you express the concepts in it to a user. If software isn't really understood by humans, I doubt LLMs will be able to generate working code for it anyway, so we get a design problem to solve.
LLM's are only as good as they are because we have such amazing incredible open source software everywhere. Because their job is to look at the types of really good libraries that have decades of direct and indirect wisdom poured into them, and then to be a little glue.
Yes the LLM can go make you alternatives, and it will be mostly fine-ish in many cases. But LLMs are not about pure endless frivolous frontiersing. They deeply reward and they are trained on what the settlers and town planners have done (referencing Wardley here).
And they will be far better at using those good robust well built tools (which they have latently built-in to their models some!) than they will be at re-learning and fine-tuning for your bespoke weird hodgepodge solution.
Cheap design is cheap now. Sure. But good design will be ever more important. Model's ability, their capacity, is a function of what material they can work with, and I can't for the life of me imagine shorting yourself with cheap design like proposed here. The LLM's are very good, but but honing in on good design is hard, period, and I think that judgement and character is something the next orders of magnitude of parameters is still not going to close the gap on.
For example, when a designer sends me the SVG icons he created, I no longer need to push back against just using a library. Instead, I can just give these icons to Claude Code and ask it to "Make like react-icons," and an hour later, my issue is solved with minimal input from me. The LLM can use all available data, since the problem is not new.
But many software problems challenge LLMs, especially with features lacking public training data, and creating solutions for these issues is certainly not cheap.
GenAI generally makes software cheaper. But there is a huge difference in how much. Prototypes and jigs may be 90% cheaper (just making up numbers here), while for production software it may be closer to 10%.
AI is taking over Senior Devs' Work is the same as IKEA is taking over carpenter's moat - no, no, and again no way.
AI lets you do some impressive stuff, I really enjoy using it. No doubt about that.
But app development, the full Software Delivery Life Cycle - boy, is AI bad. And I mean in a very extreme way.
I talked to a carpenter yesterday about IKEA. He said, people call him to integrate their IKEA stuff, especially the expensive stuff.
And AI is the same.
Configuration Handling: Works on my machine, impressive SaaS app, fast, cool, PostgreSQL etc.
And then there is the final moment: Docker, Live Server - and BOOM! deployment failed.
If you ever happen to debug and fix certain infrastructure and therefore deployment fails - you wish you were doing COBOL or x86/M68000 assembly code like it is 1987 all over again - if you happen to be a very seasoned Senior Dev with a lot of war stories to share.
If you are some vibe coder or consulting MBA - good luck.
AI fails so bad at doing certain things consistently well - and it costs company dearly.
Firing up a Landing Page in React using some Tailwind + ShadCN UI - oh well...
Software Design, Solution Architecture - the hard things are getting harder, not cheaper.
IKEA is great - for certain use cases. It made carpenter's work only more valuable. They thrived because of IKEA, they didn't suffer. In fact, there is more work for them to do. Is their business still hard, of course, but difficult in a different way (talent).
And all doomer's talking about the dev apocalypse - if AI takes over software development, who is in trouble then? Computer Science, software development? Or any and every job market out there?
Think twice. Develop and deploy ten considerably complex SaaS apps using AI and tell me how it went.
Access to information got cheaper. A fool with a tool is still a fool.
Less maintenance and flexibility. You're not really "designing software" until you have a 20+ year old product.
Vibe coders really embody the "temporarily embarrassed billionaire" mindset so perfectly.
TFA's take makes sense in a certain context. Getting a high-quality design which is flexible in desirable ways is now easier than ever. As the human asking an LLM for the design, maybe you shouldn't be claiming to have "designed" it, though.
More to the point how much of that profit is generated from selling those customers data rather than earning those customers payments?
There’s a reason why most vibe coded apps I’ve seen leak keys and have basic security flaws all over the place.
If you don’t know what you’re doing and you’re generating code at scale that you can’t manage you’re going to have a bad time.
The models are trained on all the slop we had to ship under time pressure and swore we’d fix later, etc. They’re not going to autocomplete the good code. They’re going to autocomplete the most common denominator code.
I don’t agree that design is cheap. Maybe for line-of-business software that doesn’t matter much.
That's LLMs extending C and C++ Undefined Behaviour to every project regardless of language.
-------------------
EDIT: I tried articulating it in a blog post in a sleep-deprived frenzy of writing on Sunday - https://www.lelanthran.com/chap14/content.html
What are the incentives for doing that? What are the incentives for everyone else to move?
So if proven things exist for basics, what's the incentive to not use them? If everyone decides they're too heavy, they could make and publish new libraries and tools would pick those up. And since they're old, the feature-set is probably more nuanced than you expect. YAGNI is a motto for doing less to avoid creating code debt, but writing more net new code to avoid using a stable and proven library doesn't fit that.
Many people are in position where they can’t afford risking their financial future by going all-in on startup. They just want to do honest work in exchange on paycheck and enjoy time with family after 5pm and on weekends.
Same with Salesforce, there are a few hundred alternatives
Same with a lot of software, software libraries are designed to work with the deficiencies of the human mind.
There’s no reason to think ai needs these libraries in the same way
I’m not saying the future can’t get to an ai just producing everything. I’m saying it’s just plain inefficient to keep solving the same problem over and over.
Given the choice between
A) having one AI produce a library and having 1000 produce code using that library which comes with tests human in the loop vetting documentation and examples which drastically increase the chance of the 1000 AIs doing it correctly
B) Having 1001 produce the same functionality provided by the library probably on average worse and requiring more expensive hand holding
What in that benefit of B? You might have slightly higher specificity to your use case but its more likely that the only increased specificity is shit you didn't realize you needed yet and will have to prompt and guide the AI to produce.
I fail to see how AI would obviate the need to modularize and re-use code.
I think your thought process is not taking into account what a super logical ai can do, and how effortlessly it could generate some of this code.
Using these preexisting will all become outdated. You will look like primitive cavemen if your agents don't build these from scratch every time you build $NEXT_BIG_THING.
Even local LLMs will be able to build these from scratch by end of 2026.
Hyper-optimized HTTP request/response parsing? Yawn. Far less interesting.
AFAICT, the advantages of keeping context tight and focused have not gone away. So there would neeed to be pretty interesting advantages to not just doing the easy thing.
Build times too. I kinda doubt you're setting up strictly-modularized and tightly-controlled bazel builds for all your stuff to avoid extra recompilation... so why are we overcomplicating the easy stuff? Just because "it will probably function just as well"?
"leftpad"-level library inanity? Sure, even less need than before (there was never much). Substantial libraries? What's the point?
Hell, some of the most-used heavily-AI-coded software is going the opposite direction and jumping through hoops to keep using web libraries for UI even though they're terminal apps.
The concept of using a library for everything will become outdated
It’s easy to write a cookie parser for a simple case; clearly your robot was able to hand you one for millidollars. How confident are you that you’ve exhaustively specified the exact subset of situations your code is going to encounter, so the missing functionality doesn’t matter? How confident are you that its implementation doesn’t blow up under duress? How many tokens do you want to commit to confirming that (reasoning, test, pick your poison)?
Real question: does your world model suppose super exponential gains in intelligence and efficiency?
If it does come, nothing we do now really matters. If it doesn’t come and we cash a bunch of checks assuming it will, we are screwed.
I say all that mostly in jest, but to take your point somewhat seriously: the most accurate thing you’ve said is that no one is ready for super intelligence. What a great and terrible paroxysm it would be.