Code has always been the easy part
laughingmeme.org
laughingmeme.org
The hard part is long term maintenance. The hard part is retrofitting new features. The hardest part of all is not building a big ball of mud.
Mythical Man Month is still an amazing read. 9 agents still cannot have a baby in 1 month because the problem has never been the speed at which we type.
"The thing that LLMs are taking over is easy, we humans still have agency over the hard part."
That's what he's trying to say, and I can tell you, this is not true. Programming was the hard part. That's why we got paid so much. It's the easy jobs that are immune to AI: Gardening, construction work, blue collar jobs,... etc.
Mind you not easy in the sense that the work isn't hard, but easy in the sense that anyone can do it. Those are the jobs that are ironically safe.
Anyways, "programming" is a broad concept. It can be very easy or very hard, generalization makes no sense.
The people claiming that the coding was the easy part certainly believe it.
Getting it right is much harder.
Knowing what to build is way harder.
Debugging is hard.
Dotting all the i's and crossing all the t's to get your product to ship can be hard.
Maintenance and support is hard, especially if the product is riddled with problems, but also just due to the passage of time.
Dealing with tech debt is hard.
Communicating is hard.
And all of that AI can do it now.
Sure, writing a program that makes a machine kind of do something was easy. Lots of people can do that. But then you ship a mobile app to a billion users and discover that people are genuinely wired differently.
different cultures, different mental models, different expectations
Now you have to accommodate and express all of that complexity in a language whose only reader is a machine that tolerates zero ambiguity. And you have to do it in a way that other engineers can read, reason about, and build on top of without the whole thing exploding. That's not requirements gathering. Its literally writing it down
You're doing the thing where you read code like a fish breathes water and conclude it was easy to write. You can read a Nobel Prize novel in a weekend too. The readability is the achievement, not evidence it was trivial.
Edit: I got pretty heated about this and wrote up a proper rebuttal: https://promptless.ai/blog/technical/writing-code-was-hard-a...
Are humans starting to adopt LLM patterns or was this was ironically written with an LLM?
That said, I'm surprised you didn't bring up Marx in your essay in the later sections. I vaguely remember he had some thoughts about derivation of value from labor vs "ideas/capital". Whether or not you agree, this debate is reminiscent of that just moved up one level to white-collar workers.
As a beginner syntax is the hard thing, remembering how to write a thing. As a beginner you don't even think about structure, how to write maintainable or testable code — you're just happy it eventually works for you. Depending on the beginners character they might fall into the trap of thinking more complicated code using more advanced language features is a sign of a genius programmer.
When you're getting better you realize that writing the code is indeed the easy part and that you should avoid writing code that is too clever unless it is well localized and neatly tucked away. Writing clever code is something that does not impress you at all — quite the opposite as it is usually just unnecessary bragging. The hard part after all isn't writing clever code, it is finding good abstractions, staying consistent, writing maintainable and testable code without being too smart. It is understanding and then solving the real world problem in an elegant way. It isn't writing what the customer think they want, it is writing whst they truly need.
That does not mean actually writing the code isn't specialized work that requires skill. But it just isn't the hardest part of the job. Just like knowing how to use the tools isn't the hardest part for a car mechanic. Making sure that the car drives reliably, you chose the right parts, you did it fast and efficiently is.
0: https://en.wikipedia.org/wiki/The_Mythical_Man-Month?wprov=s...
1: https://www.laputan.org/mud/
Edit: This also isn’t to say that _millions_ around the world aren’t employed just to write code. This isn’t to say LLMs aren’t hugely disruptive. This isn’t even to say they aren’t also good at the hard parts. It’s just to say there’s a difference between coding and systems design and one is harder than the other in most cases in most jobs.
I give you a bunch of high school students with average grades and no programming experiences. How long do you need to educate them so they can implement a JPEG decoder from JPEG spec, without a reference library?
It's a 100% unambiguous task. One doesn't need to understand the math behind discrete Fourier transform to implement JPEG. It's just a 1 to 1 translation from the spec to code. Must be not so hard!
This is completely different though. In the past I'd always go back to paid SaaS when the mud broke apart.
Not true for the past 18 months for me, I am developing features, maintaining code, all via natural language to a much higher standard than I've ever had in my business before.
A low bar, perhaps, but it's definitely not the same.
It's difficult when you're first learning but there are definitely much harder skills to learn.
It's the easiest part because the hard parts of the job are everything else -- you're a knowledge worker so people look to you to make decisions and figure it out. You figure it out and make it work for whatever "it" happens to be.
If you thought coding was easy, wait till you see the competition for knowledge workers. You're in a spot now where the part that made you valuable (implementing business rules in software) can now be done by virtually anyone.
Doing all the non-coding parts (or, as you put it, "the hard parts") can now be done by almost any white collar worker.
"Knowledge worker" isn't a cutesy phrase, it means I don't get paid for my time, I get paid for what I know. Contrast that to, say, working retail where you are paid to staff the store from 8-6. It's not a value judgement (retail is hard work) it's a description.
We've already had years and years of predicting the death of software engineering to offshoring and that didn't happen for the same reason. India turns out plenty of fantastic engineers who can do my job. Those people also have better options than staffing some cut rate code factory, and you can't substitute the latter if you need the former. But nice try lol
What you appear to be missing is that (if AI coding is as good as we are told) there will considerably more people with the business knowledge to drive an AI to create their solutions.
The bit that made developers valuable was the ability to actually implement those business rules in software. You will be competing with all those laid off devs as well as those non-developers who have all that business knowledge.
In simple terms, there are two groups of people:
1. Developers, who have some business knowledge, and
2. White collar workers who have no development knowledge.
Previously (or currently, say) the supply of solutions providers came only from group 1. Now they come from both group 1 and group 2.
The supply of solutions providers just exploded, you can expect the same sort of salary that the people in group 2 get, which is nowhere close to what the people in group 1 used to get.
I'm not a code factory who occasionally talks to the suits. That isn't the job lol
The problem you are facing is that "person who talks to business" is a huge pool of talent, and now you have to compete with them. Previously your only competition was "person who talks to business and can code".
I do not get paid to write code. No software engineer does. The more senior the engineer, the less code they write.
I don't even really talk to the business folks, that's what a PM is for.
I already told you what I actually do, you're free to read it and learn. Or not, I ain't the boss of you
Nobody listens to someone who talks like this. Nobody learns from someone who talks like this. You're not a leader and you're not a very good software engineer and likely if you boss anyone around, they think you're a clown.
But the sad truth is that most software can be or it's done with shitty code that "kinda works" as long as the CPU it's fast enough.
But that doesn't mean there isn't some tricksy stuff. All the linear algebra in graphics programming takes awhile to wrap your head around. Actually, game programming in general i find a bit hard. Physics, state management, multi threading, networking...
Translating that into whatever language you chose is not that hard.
People love to lionize it, but honestly I can teach the basics of coding to anyone in a weekend. I love teaching people to code. It can be frustrating to learn but it's just not that difficult. I've mostly written Python and Ruby and Node for my career. They're not super hardcore languages lol.
What is hard is learning the engineering side. I don't get paid for the code I write, I get paid because I get handed a business wishlist and it's my job to figure out how to make that business reality and execute it, from start to finish.
I tell my boss what I'm going to be working on, not the other way around, and that's true pretty early in your career. At my current level of seniority, I can personally cost the company millions of dollars. That's not even a flex, most software engineers can do that. Learning to make good decisions like that takes a long time and a lot of experience, and that's just not something you can hand off.
Yeah building a web app can become somewhat easy, but is distributed machine learning? What about low level kernel code?
Both are needed to do practical work, but they are orthogonal.
There is a nuance in what you say. You say it is "still easy" but it is not. It is not enough to take a course on operating systems and learn C to start contributing to the operating system kernel in impactful way. Apart from other software "courses" that you need to take such as algorithms, advanced data structures, concurrency, lock-free algorithms, probably compilers etc. the one which is really significant and is not purely software domain is the understanding of the hardware. And this is a big one.
You cannot write efficient algorithms if you don't know the intricacies of the hardware, and if you don't know how to make the best out of your compiler. This cannot be taught out of the context as you suggest so in reality all of these skills are actually interwhined and not quite orthogonal to each other.
If you take the skill tree you need to be a kernel contributor, it does not take much to jump over to database systems development, or writing GUI. You may argue that the barrier entry for web dev is lower, but that's because of all the foundational work that has been done to add guardrails. In kernel work, they are too expensive so there's no hand holding there. But in webdev, often enough, you'll have to go past the secure boundary of those guardrails and the same skill node like advanced data structures and concurrency will be helpful there.
Kernel dev is not some mythical land full of dragons. A lot of the required knowledge can be learned while working in another domain (or if you're curious enough).
Creating a high performance general purpose database is hard, but once it exists and is properly configured, the SQL queries are much easier. They'd better be or we wasted a lot of time building that database.
I don't know what that entails, but something is going to happen.
I got into a discussion with some Rust compiler folks yesterday. I called Rust the "final human language we'll serialize our thoughts to": it's easy to write for LLMs, is super type safe, ergonomic, easy for humans to read and reason about, and has really nice deploy characteristics - single binary, no GC, bare metal, etc. If Python and Rust are equivalently easy to emit, you'll probably choose Rust if you're not bound to other choices.
People quipped back that this was absurd and that Rust is built for decades of future human use, that this kind of talk would put people off of Rust, and that they need to think of the future.
As if anything will be human in the coming decades.
Programming languages were punch cards.
Maybe if you're willing to write insanity like this:
struct Zero;
struct Succ<N>(N);
trait Add<Rhs> {
type Output;
}
impl<M> Add<M> for Zero {
type Output = M;
}
impl<N, M> Add<M> for Succ<N>
where
N: Add<M>
{
type Output = Succ<<N as Add<M>>::Output>;
}
fn add(a: u32, b: u32) -> u32 {
a + b
}
If it is just as easy to emit a language that is type safe, why Rust?
If it is just as easy to emit a language that is type safe, why Rust?
I think it will go the other way - what use is a language with the poor ergonomics of Rust if humans aren't in the loop?
But if coding were hard, then writing small pieces of code would be as hard as writing big pieces. To make an analogy, playing the violin in tune doesn't get any easier, the shorter the piece that you have to play.
Developing software is hard. Some sort of "phase transition" occurs when a project gets big and complex, where coding is no longer what makes it hard. And writing software in a way that is not a net burden to a project or organization is hard, involving not just complexity but humanity. Most smart people in an organization have subtly arranged their affairs so that their career progress doesn't hinge on the success of a software project.
I admit that I only say these things as an observer, since I can code all day, but didn't pursue a software development career.
I also admit that I'm waiting for AI to handle the second two levels of software development. I'll concede that AI can develop software when The Mythical Man Month no longer reads like it was written yesterday.
It's in the name. Coding is taking an algorithm specified in some manner (pseudocode, diagrams, natural languages, thoughts,...) and transforming it into a sequence of instructions, statements, and expressions, that can be executed by a machine (either directly or through an automated process).
We have solved the coding difficulties on several front with things like programming languages (no need to type opcodes), syntax highlighting, linters, snippets, editors, IDEs,...
But someone still have to come up with the "Algorithm", and that's where it's hard. Usually because it's a combination of two sources: The business domain and the technical constraint. That's where people are failing.
But we did manage to create a lot of building blocks, like the standard algorithms and their data structures, libraries that provides an abstraction over a subdomain, frameworks that provides a scaffold to the thinking process,... But the developer still have to solve the system. And that system can get complex real quick if he's careless.
I do believe if you fail at the coding part, that's easy to fix with a few courses (or books) and some practice time. But the system thinking and the solving part is not easily taught. It's not even related to technology other than the latter being the domain it's exercised.
Coding is easy; design is hard(er).
The difference is that we enjoy sitting in a chair for ~8 hours a day laying dominoes. A lot of folks do not like that.
Programs are just virtual machines assembled from numerous smaller parts, not so different from a bicycle, car, or mechanized assembly line, but that's not at all how I thought of them when I was first getting into writing code. I'm not sure I even had a mental model at that point, or if I did it was too simplistic to build anything useful with. It was after my mind picked up the machine model when I started to become capable of writing code and eventually designing and build software from scratch.
LLMs are more like a trench digger with a cat's personality. It can helps in some cases, but are more likely to destroy a field. And good luck if you have some difficult terrain to pass through.
The others also may contain wrong information, but the risks are lower and not being automated means the risks are not compounded.
I personally believe we need more trustable source of information rather than automated way to transform it. Especially for the low hanging fruit of coding, which still require to presolve the problem and put us back at the real reason to have a developer.
And one thing that people seems to forget is the wealth of pre-LLM tools to speed up coding. No one uses notepad (from Windows 7) to write code, which is what they keep brandishing as the alternative to their agents and what not.
Why do you think in most technical organizations the higest ranking and highest paid engineers generally write the least amount of code (often none)?
Try running a business that doesn't have the revenues to support high wages and you'll quickly figure out why you will pay as much as possible every single time: It means you can buy your way out of hiring the riffraff. Why do you think these high paying jobs were premised on weird trivia tests and other things that had absolutely nothing to do with the job? Hint: It was a social test to see if you'd fit in to the culture.
There have always been legions of people in India ready and able to write code for practically nothing. It was never hard or expensive. But they didn't fit in socially.
Yes I have 30 years of experience and there were still areas that were not easy but man it was fun. Writing the code, building and deploying product is easier than it was before by a huge margin.
Skicamslive.con if you're wondering what I built. Feedback welcome
I’ve also found joy again in building things, but I never fetishised the code myself anyway, I suppose I just wasn’t built that way, which might mean I was always biased to be like this.
In fact your example demonstrates what the article says. Yeah the LLM made coding easier, and probably reduced your shipping time from a few days to a few hours.
Now - since you have solved the hardest problem and have all this valuable code - how long will it take you to turn your product into a business and generate enough money to support yourself?
That's the hard part.
> That's the hard part.
It's now even harder because SNR fell off a cliff. As the effort to produce a product approaches zero, the financial viability of that product goes to zero as well.
It's nice you got something out of it in just two hours. If the LLM companies are doing their caching right, the next person to ask for this set of apps with prompts close enough to yours can get it in five minutes.
Also there's a typo in the URL.
Same with coding. Most programmers, and writers, are average. They are not doing amazing work. They get paid 80-120k, same as the HR professional, or the account manager.
Creating average work was always relatively easy for writing and coding and is now relatively easy for everyone.
Code being the easy part was predicated on how long it took to build a product, and the impact that had on product management, sales, and marketing.
When the time to build collapses, all product/sales/design/martketing mistakes are forgiven. You can pivot so fast, that mistakes in other domains dont matter as much and are reversible
All of the axioms we previously held true need to be rethought
Which should be perfect work for Ai.
Users will churn quick if you aren't reliable or useful and a security incident can be company-ending for a startup.
I must be living in topsy turvey land because this is literally the opposite of what is true. When the time to build collapses, those things become the criticality of the entire product. From a customer perspective, those were always the things that mattered, the customer story. No customer cares how a thing was coded, they’ve ALWAYS cared about all those other things.
if time to build takes 2 months, just build it and iterate.
or just rebuild the product to the customers liking...
Today we call it "vibe coding" when people use an AI to write software without reading the code, or even learning how coding works. But people have been doing that for ages. Most "Perl programmers" back in the day never even attempted to learn the language, and often weren't software developers. But despite their horrible coding skills, the Perl worked anyway. And thus the language got a reputation for being hard to read, despite it being amazing that it worked at all.
Perl is still far and away my favorite language. I get things done so much faster in it, and programs I wrote 25 years ago work perfectly today on the latest systems. (Maybe that's the problem? If it were a real language, it would've broken 5 different times by now! And then I get paid to fix it... I think I understand software engineering now...)
It's just not. I've been a developer for 25+ years, and in technical diligence looking at companies getting investments for seven, and have done diligence on 100+ companies. It's ALL OVER THE PLACE. It depends on the product, the company, the team, the way the company is managed, the business domain, etc.
For some companies, products, and teams.. the code absolutely is the hard part, and building that insanely sophisticated software is worth millions. I've seen scientific software that sold for millions of dollars per copy.
For others, the code is essentially commodity plumbing around some operational knowledge of a domain that makes nice dough with minimal code complexity. I've also seen founders who were going to spend the rest of their days floating around the bahamas because they wrote the right PHP-ball-of-mud in the right domain at the right time, sigh.
The world of software is vastly broader than the vast majority of programmers think. And there are a lot of very, very different ways to make money in it.
For example, I have worked with SAP a lot...the largest ERP system in the world by some margin and I have used it's internally built tools that extend a small amount of developer functionality to the 'IT department developer' that gives a user with knowledge or .NET and SQL the chance to make little validations or do some bespoke data visualisations pretty quickly. This was trivially easy and pretty sure AI tools will make a developer redundant in this context because the documentation is good and there's a lot of it.
Contrast eg hooking up a system like SAP to an unusual non-standard Ecommerce offering and you have a far more complex problem (that interestingly doesn't require huge amounts of code but does in fact take a long time because of lack of documentation and a certain amount of understanding required). I would also point to programming games, which I enjoy...compare using Unity with some C# scripts for making games, to building your own engine (which will pretty much become redundant soon anyway if it already isn't). AI is very good on the Unity stuff but I suspect would struggle with it's own engine for a specific game.
We used to brush that off with the "we'll fix all of that once we've shipped", now we brush it off with "doesn't matter, AI can fix it later easily". This applies to knowledge about the code, domains and quality itself, too.
To me, this is a reasonable tradeoff to discuss, and sticking to either extreme ("AI is cancer" and "AI is the silver bullet") feels silly.
There's real risk here, and I do see a lot of seniors act like kids in the candy store. That speaks volumes to what AI really unlocks (cheap experimentation, for one!), but also warrants caution.
Based on the data (not great quality tbh...) we have, the net speedup is more realistically around 5-10% of the total time of software engineers, and we're yet to see the cost of that speedup.
- communication between humans
"what are we to build?"
"what is the architecture?"
"how shall we design this?"
etc
- architecture review
- design review
- code review
- docs review
- ...
- understand what is possible
- and how to achieve it
- architect
- design
- review
But even with that one constraint about human-to-human communications, LLMs are improving throughput: by writing better docs faster, by helping us get the gist faster (though using LLMs to read docs that could have prompts embedded is scary), and so on.
Personally, where the communication burden is intense I don't think we'll see 10x, 5x, not even 25% efficiency improvements. But now consider projects where the communication burden is minimal as there is only one human -- personal projects, open source projects, that sort of thing. In those cases a 5x, even 10x efficiency improvement is not out of the question. Many projects have communications burdens that are not so intense that they can't experience 2x efficiency improvements.
The challenge will lie in safely maximizing those improvements and doing it better than the competition.
Even with coding agents, there is still a need to understand what it’s doing, how it will interact with other systems, where bugs or edge cases will show up and many other aspects that become security risks when ignored by someone that YOLO’s their vibe coded app into production
Besides, loads of software that’s human written has people maintaining it that don’t understand what it’s doing or how it interacts with other systems or where bugs or edge cases will show up etc etc too. In fact I’d say most software is like this.
LLM’s probably make less security holes than humans at this point.
They bring in a high priced consultant who spends a few minutes looking at the machine, reaches in and pushes a switch and suddenly the machine starts working.
When the manager gets the invoice, he calls the consultant demanding an explanation for why it cost so much. After all, the consultant only spent a few minutes looking and then flipped one switch.
The consultant offered to send a more detailed invoice and the manager received one that said:
- Flipping a switch: $1 - Knowing which switch to flip: $999
In other words, the writing of the code is like flipping the switch. It’s the rest of “coding” that’s difficult.
I guess we just hallucinated leet code too.
Both are somewhat true, and yet, I'll still be quite happy if we have AI that can do them.
I'm certainly not trying to trivialize the progress that LLMs are making. I'm trying to be realistic, noting both the strengths and weaknesses of LLMs, and what that means for the fields they touch.
- Non-trivial arithmetic
- Puzzles involving combinatorics
- Chess
etc. etc.
Afaik the best AIs can win now but even they aren't playing 'perfect' unloseable games.
I wonder if someone with real experience/insight thinks that this claim is revisionist.
It’s going to be a hard transition, but we can’t pretend it’s not happening, that won’t get us anywhere.
No author, this isn’t the same as SPAs and CI/CD.
This isn’t just happy tools helping us focus on the business side.
We’re devaluing all white collar work. The thing that keeps the US economy afloat. Even if this tech requires human oversight, why would companies keep you when they can hire someone overseas at 1/10th the cost and get to 80% of the productivity with AI.
Anthropic just dropped their safety pledge. Do you think they’ll hesitate as they transfer wealth from workers to their shareholders?
Please people. Stop being avoidant. Stop pretending it’s a meritocracy and you’re at the top. Stop pretending the one thing about the job AI can’t do is the job.
This is the exact cope I’m talking about, as if these tools are just good at code generation and the actual work was always communication or architecture or something.
Code was never the easy part.
If it was, then AI and LLMs would have been of no interest for coding.
Self evidently wrong.
Software developers have spent the last twenty years blabbing about how product management is useless and coding is the one true skill.
Coding is hard when you're learning it. "How do I use templates in C++? How do I handle error checking in Python?" etc. But it's the most basic piece of software development.
Ask yourself honestly, is this genie ever going back in the bottle? If not, you’re gonna have to find a way to come to terms with it my dude.
> Or perhaps you are the one who is “coping”?
> Ask yourself honestly, is this genie ever going back in the bottle? If not, you’re gonna have to find a way to come to terms with it my dude.
I think you misunderstand the GP: The developers writing this, or similar things, are seemingly unable to understand that they'll be un/under-employed along with everyone who is anti-AI, and this is their coping mechanism.
After all, if you don't need coding knowledge to produce an application, and only need domain knowledge, you are now competing with 10x more people for the same job.
Maybe it is a good thing, but I don't think that that fact, regardless of veracity, is relevant to the coping argument, though.
All the developers prattling on about how they are moving to a higher level of abstraction, or how they are moving to the more difficult parts of the process are ignoring that those parts traditionally paid less and that they are now competing with a larger pool of people who can provide that skill.
The difficulty of course will be recent graduates. I genuinely feel for the difficulty they’ll have.