AI is removing the middle class of software engineering?
blog.florianherrengt.com
blog.florianherrengt.com
This part of the article hits home for me. With AI, "bad" engineers can now amplify their "bad" engineering x10 across the organization. The most egregious of these cases for me is often long tenured engineers who have lost interest in the craft, creating a dangerous combination of having enough merit to ship but not enough interest to make what they ship _good_.
I am still a firm believer in garbage in -> garbage out, AI is only as good as the abstractions and contracts you put in place for it. I don't subscribe to the idea that AI generated code is fundamentally bad, just that people lack the right skills today to wrangle agents into writing good code.
Earlier in the year I put together a talk for my company on what the future of architecture & design means for us in the career, I'm very proud of it and will share here in case folks have their own thoughts to share on the topic: https://youtu.be/SIZrt9Rt05Q?si=W57eirniWmoSFeBu
I've often had it test and benchmark against the wrong things = no test.
It also writes over-engineered code. So yes sort, maybe.
If you're a good dev, you can totally prompt Claude to not do this and correct itself, that's not an issue. The issue is that bad devs won't even notice this is happening in the first place.
At my org we use Github Copilot as our AI tool for devs, both internally and for vendors (Including a WITCH =/).
Where it gets ugly, is that we have a -lot- of WITCH provided code already in our systems, and as a result GHCP winds up often preferring the existing (terrible) patterns.
I've done some things to help mitigate at least; Adding instruction/skill/agent files, tossing in some LLM-built .NET analyzers to catch the worst anti-patterns to warn on build and error on CI, and making sure to call out when the vendor people are obviously not even reviewing what the LLM generated for them [0]
[0] - Simplest case being, EF Core mappings where the datatypes do not even exist in the target DB...
I for one tend to care less about the minutiae of solutions implemented by AI as long as it gets the job done, I do care about architecture and design decisions and correctness and I have ways to steer and verify these when working with LLMs but I couldn't care less about it writing "good" code. Bad engineers also produce better results with AI at least when they're working in established frameworks, AI doesn't really need a lot of high level architecture input when designing or building a web app with a common stack, so as long as you're not working on something that's completely novel I don't think it will make a strong difference.
Maybe designers think the same way about the AI generated web designs I have Claude Code do for me but to be honest I don't care, I just know that before this tool existed it would have taken me weeks or months to come up with a good design and I would have to rely on prefabricated UI libraries and stuff like that or pay a designer tens of thousands of USD to make one for me, now I can get a (for me and my customers) perfectly acceptable and professional design within a few hours. So maybe I'm also a bad designer that amplifies my bad design taste 10x in my company, but the fact is the stuff ships and makes money and the customer is happy! And I can tell you customers or users don't give a shit about how good your code is, they only care if the software works and does what they want!
There are valid situations where the best code you can write is code you never look at and throw out the next month; there are equally valid situations where the best code is well thought through and reasoned abstractions for an area you expect to become core to the business in the near future.
I think with AI coding, what we call "good" code changes. Lots of abstractions really only exist to help load the context into the human brain so that they can solve the next problem. If an agent can just search and find all the places to make a change, or to duplicate code with small changes for the next problem, is that bad? Does is just feel bad because that's not what we're used to?
We use structured looping instead of gotos because that makes sense to us, but the compiler still turns it into jumps in assembly. If our interaction is now at a higher layer, do we need good "code" or do we just need good "architecture"?
I don't know, but it's just something I've been thinking about lately.
Doing the right thing for the customer is independent from good design and good code. It’s a problem of requirements and project management. This is an excuse some poor programmers use, that they can’t write good code, but at least they fulfilled the customer requirements :D
On a large system, the customer being happy today isn’t enough. You need other engineers to be able to understand the system.
Have you ever been on call and been woken up in the middle of the night to fix a production incident in a system you didn’t write?
If everything you build is small, isolated and easy to replace (basically fire-and-forget), then yeah... who cares? Ship the ugly thing, get paid and move on.
If you’re going to be working on something for the next 5+ years, you should definitely spend some time thinking about what you’re doing.
The past 5-10 years or so saw me pretty beaten down though with software engineering, and AI was the final nail in the coffin that caused me to leave the profession in later middle age. I thought software as a business had "lost its way" from building great products with attention to detail to "how do we addict as many people as possible as quickly as possible". Think about the degradation in Apple software from say the "it just works" era to now.
With respect to AI, I'm not really against it, and I find it extremely valuable in my personal projects. I just feel in a large group/enterprise context that it's replaced a lot of tasks I actually enjoy doing with becoming an editor for what feels like a slightly inebriated junior developer. Or maybe it's better to say a junior developer on a mild amount of meth, because as you say this developer can churn out semi-but-not-fully-working code at an astonishing rate, and then I feel like it's often my job to mop the slop off the floor. Pass, not interested.
I feel lucky to have had my career during what I consider the golden age of software engineering, but I'd note I don't think that golden age lasted even a full career of one person.
Paying for software was the norm, so it was more clear what the "product" was, and software writers had a direct incentive to write better software.
Updates could not be pushed out so you had to be pretty sure your code worked before you shipped it. Having to ship physical media to all your customers for a bug fix was very expensive. Any new release was a big deal, so you had to put some real thought into what features it should contain.
Significant amounts of your development time were not spent trying to work around browser bugs, or differences in browsers, or supporting random old browsers that your customers still use for <reasons>.
Stack churn was much slower. The feeling of constantly trying to keep up with a treadmill was much less.
Users, while often not technology experts, were a much more competent slice of people than the general public who showed up when they got internet service and a computer at home.
The only ads were in print in trade magazines or publications like Computer Shopper. Yes, people actually used to buy a magazine that was nothing but ads.
Since it sounds like you built software during that era, thanks. Thanks for the memories.
For the vast part of my career I worked for good companies that I thought were comparatively very well managed, and I was especially fortunate that overall I think I had excellent bosses. But the reality of the Internet age and CICD in particular is that speed is much more important than quality. I don't even really disagree with the business imperative of "ship, ship, ship", but for people who really value their craft, it can be discouraging shipping stuff you know is always kinda half baked. I was definitely not a "gold plater" either, and time pressure was certainly a thing pre-Internet, but as you say mistakes were a lot more expensive then so there was more business rationale to ensure quality before a release.
To me, the best time was late 90s, early 2000s. We had a lot of autonomy. People would just trusted that we knew what and how to build it. I could focus on building a great product. Overtime, we lost control, to the point that we now work based on jira tickets made by managers or product owners with one tenth of the experience that we have.
What year did you leave? And what are you doing now?
The issue is that with no reins, the LLM is a fire hose of bad code compared to the garden hose of bad code orgs had before. A good engineer, with a good model and harness will produce great stuff. A bad engineer with a good model and harness will produce something faster, but it will be worse.
A good engineer, without LLM assistance, will still produce great stuff.
I've never really seen that. What I've seen is the much pragmatic take of marking the source code with a few comments to highlight the problematic areas and then goes on with the implementation. Refactoring can always be done later when the first batch of value has been extracted.
There's always tradeoffs to balance and perfection is something you inch towards, not something you get done in one go.
...as Mickey Mouse was fond of telling me as I waiting for the ride at Disney World. Or it was my drill instructor. can't remember which.
Not fast enough to keep their job these days.
Time was always the limiting factor to code quality, good engineers satisfied the classic "good", "fast" but not "cheap" selection of those three classic options.
I very sincerely doubt it is possible for even an incredible engineer to keep up with the delivery schedules required to ship products now. Not to mention that frontier models do ship pretty consistently good code. By far the biggest source of issues I see is not "poorly coded" but "problem poorly specified". We still need good engineers, because they can understand how to do decompose problems well, but I don't know anyone who writes code by and anymore (other than for fun).
What's the current delivery rates? From my past experience, any feature can take several weeks from idea to be in a somewhat usable shape for production. While the actual coding is often less than a few days. A lot of time is spent on gathering requirements and resolving conflicts between them.
I believe most current improvement in speed is just moving from idea to demo in a few days, then spend several months fighting bugs. While the customer can't really use said feature.
This is an outdated view.
Current timelines I'm facing are to be going from "thought", through customer trials and being fully live in the product and ready for sales in ~3 weeks (from kick off to live in app is a bit more than a week). This is for a full product feature that could easily be standalone. In 2023 I would say the timeline for a similarly shaped feature at another startup was around ~3 months (and the team at the time agreed that was an aggressive timeline). Bug rates are not noticeably different than other teams I've been on in the past 20 years.
Nobody I know working in startups is still building demos with AI like they were a year or more ago (for work), that's seen as largely a waste of time since you can just ship the feature and be experimenting with customers much faster.
On top of that everyone working in startup land knows that SaaS's days are numbered, so you need to be shipping working software fast enough you can get ahead of the curve to navigate where things are going next.
My issue with these kind of numbers is that they never contrasted them with a NO_LLM practice while keeping everything the same. It's always perfectly fine to YOLO generated code straight into prod, but if you handwrite it, you need to fill several forms in triplicate to even make it to the review phase. Then someone claims they are 10X-ing their productivity with AI.
> you can just ship the feature and be experimenting with customers much faster.
That's basically what I said. Instead of shipping something that have some value to the customer/user from the get go, which may takes one or two months, you spend one or two weeks on it, ship it, then frustrate your customers/users when things aren't working or keep shifting around.
For all of AI being touted as the best thing since sliced bread, there's been little to no value for humanity as a whole.
Most of my team's time is spend carefully reviewing PRs and iterating on improving new ways we can ensure the product works well, the product is hardly "YOLO'd"
> then frustrate your customers/users when things aren't working or keep shifting around.
All of these products come at the request of customers and they are generally quite delighted with the results and equally delighted with how fast we can deliver.
> For all of AI being touted as the best thing since sliced bread
I don't think it's the best thing since sliced bread, but I am telling you that your understanding is weirdly out of touch. I know HN doesn't have people working startups anymore but what I'm experiencing at work is a lot of serious engineering work and discussion around delivering quality products rapidly (as well as improving process so we can get ahead of transformations in what a 'product' is).
It sounds like you have a view of the world and want to stick to it, in which case there's not much point in arguing. If you search my comment history you can easily find around 8 months ago I would have largely agreed with you, which is why I opened mentioned that your view is "outdated". This space has changed dramatically in the last year, and continues to change in ways that surprise me.
Let the LLM wars start!
We are pushing tons of code and now our CPU usage has grown exponentially over the past year because the bad engineers just ship whatever Claude gives them and do not think about the consequences.
Our biggest consumer of CPU right now is HTTP connection churn because engineers are creating new clients every request we handle. If the engineers would just think for a second, push back on Claude, even Claude would tell them this is bad. But they don't... Platform engineering is now 10x harder with terrible engineers and unlimited code machines.
Don't even get me started on ffmpeg usage, engineers act like the resources are unlimited.
The term for that is "10x AI engineer." Anyone who has anything negative to say about such people is just jealous of their insane productivity and speed.
Really? I have never seen that. The expectation was that you could create the code that compiled on day one.
Sometimes this can be a death by a thousand cuts. Any individual change may not impact performance to a noticeable degree but when they're pumping out a 10x increase in commits it can be a slow decline.
Just look at how they're merging ~300 commits a week into bun.
Natural consequence: Then they never grasped the concept of computational complexity.
O(n) Vs O(n²)? They have n, what's the difference? Python is fast enough. The only thing that matters is shipping features fast! Features! Our competitor will have this next week, we need to write code fast, everything else is a matter of adding more compute, which we will pay with revenue!
But the core question of “how does this behave as N -> \infty?” is asymptotic behavior (ie: limits) which were developed for calculus and are very much part of the foundational calculus canon.
Big O notation was invented in 1894.
The visual interpretation/intuition of Big O notation can be a useful way to build a visual intuition of what a function's derivative and integral "shapes" may look like, so some Calculus books teach Big O notation, too.
The missing part of mathematics education, IMO, would be to focus more into developing the intuition of what something means, instead of the current focus on getting some (numeric) results.
You can't just skip arithmetic drills in favor of intuition and still come out with students who are prepared for further study in math. There's a reason Kumon etc are so popular - parents are replacing the lack of mathematics drills in schools with after school options, leaving behind all of the kids whose parents can't afford it.
And there still are arithmetic drills, it's just not the only focus in early math education.
Kids can absolutely learn complex concepts early, they just may not be able to formally write them out until a few years later. But they’re kids, so who cares? By the time they need to be able to write out math equations, they’ll understand the underlying concepts on such a deep level that it doesn’t matter how long you make it, they’ll plow through it.
I was a skeptic, and am aware that I sound like a cultist, but damn if Montessori isn’t something special. I highly recommend it.
0: https://www.montessori-theory.com/montessori-trinomial-cube/
AI disease is encouraging "sketchy process and minimal checks on the software quality." QA has been eliminated from my team, and the QA engineers that are left have been declared to be developers now.
Gotta move fast, and I guess making sure the stuff we ship works was "slowing us down."
Hiring pipelines that tested the wrong thing have existed for years but the problem is magnified 10x when you test for something that weakly correlates with ability at best which an AI can do better than a human.
This is leading to stuff like incompetent junior-level engineers being hired as principals.
That's basically it. It is surprising hard to find people that can do both, but engineers are becoming much, much better at the first gate while flaming out on the second.
You assume those people haven't already left, been kicked out, or were hired to begin with. We're not in a rational job market right now.
i've gone this route a few times in my career, it's very stressful and involves angry/panicked people and many all nighters. Also, the glory fades fast. would not recommend.
There's only so much you can do -- making reasonable assumptions, choosing suitable data structures, database indices, testing various workloads, etc. -- in a limited test environment.
You may spend a week optimizing a feature that only 10 people use or that never gets to the point where it becomes an issue. Or you may have something that can't easily be tested at scale, such as various counts or other dynamic data that are determined by complex queries that you may (likely) find you need to cache but don't necessarily know which values will become issues until you start using the system.
Likewise, improving performance pushes the limit at which performance regressions happen allowing more data (documents, triangles/pixels, etc.) to be processed. This allows things like more complex game graphics. That in turn makes it harder to improve performance for the next round (more advanced triangle/face culling and pre-processing).
There can also be trade-offs with things like data layout, memory usage (caching and memoization), or implementation. For example, when processing XML/HTML data you could use DOM (more memory and upfront parsing, but easier to perform complex queries across the data), SAX (less memory, but more complex to process due to tracking state), or reader API (similar to SAX but a different processing model).
There can be challenges with various features, such as type checking with higher-order generic types. Others add various levels of overhead, such as parsing a program, constructing an AST (Abstract Syntax Tree), generating an IR (Intermediate Representation), the optimization passes and final code generation.
JavaScript evaluation for example is complex. Before Chrome the approach was to use a slow interpreter. IIRC, Chrome was the first browser to introduce JIT (Just-in-Time) compilation, leading to faster JavaScript and eventually more complex applications running in that language. Modern browser JavaScript pipelines are complex in order to achieve and maintain performance:
1. start interpreting the code on the AST so it is run immediately (or only rely on (2));
2. generate a machine code equivalent of that interpreted code (for faster baseline performance);
3. run more aggressive optimizations on known types based on profiling/analysis for even faster performance, including special handling of things like asm.js.
[1] https://v8.dev/blog/ignition-interpreter
[2] https://benediktmeurer.de/2016/11/25/v8-behind-the-scenes-no...
[3] https://www.cs.cornell.edu/courses/cs6120/2020fa/blog/tracem...
[4] https://webkit.org/blog/3362/introducing-the-webkit-ftl-jit/
He gave them a lengthy, grueling, hyper-detailed tour of the entire facility, encompassing the HVAC systems, electrical systems, network and computing systems, finishing with about 20 minutes where he had them stand inside a hot aisle that he was just outside of, giving a fantastic soliloquy on the importance of code efficiency, and the consequences of ignoring it. It was hilarious to watch from the comfort of the cold aisle, knowing full well what he was doing.
I’m personally of the opinion that everyone who works in software should have to rack a server and bootstrap it. Physically mount it, cable it, and get the *nix distribution of your choice running on it, serving Hello, World.
Everywhere I’ve worked, there is a marked difference in the quality of engineers who had played with hardware - even those who merely had expressed interest in it, and maybe had an RPi - and those who had not. There is something about physically touching the thing that runs your code that makes you better at it. Maybe it’s a correlation between “wants to play with something unnecessary but adjacent” and “curious enough to ask why more frequently,” but I swear, it exists.
But you don’t really want lots of idle or underused servers, aside from burst capacity management. So if they universally and consistently wrote more efficient code I’d expect a smaller datacenter. Full of still busy servers but just less of them.
I'd try and push for some "lunch and learn" meeting where the engineers get lunch catered and in exchange sit in on a meeting where you explain your point of view. Without monetary incentive it'll be hard to change the culture, but not impossible (and food goes a long way in greasing the wheels).
Not necessarily, great engineers do also ship temporary code they didn't have the time to trim.
Our process is of 1) make it work, 2) make it right and 3) make it fast; not necessarily that engineer had time for the 3rd step.
You should have plenty of data to review regularly and push back on any teams that are causing problems. That's a process problem and you need a process for it.
Trace the increase back to specific deployments, call out those teams, and make them fix their shit.
If you are closing one ticket per week with "good" code but your teammate does three with "bad" code - it's actually you are a bad employee. Also they may say you are a toxic one.
I would much rather have someone on my team who ships less but whose work I can trust than someone much faster whose changes leave me wondering what problems we’re going to discover later.
And when production breaks (and it will), I need the person who made the change to actually understand it well enough to help fix it, instead of showing up with no idea what is going on.
You can obviously be an asshole about how you do it but I don’t think pushing back makes someone toxic.
You need to be flexible and compromise when the business trade-off makes sense. But you also need a backbone. If you think something is going to cause real problems, bringing it up is part of the job.
Me too, but it is not what happening across the industry. Instead they are pushing for more LLM usage as well as more features. And faster, faster!
A big part of this is ensuring that a "bad" engineers can still write solid code and also investing in systems that make it easier for us to review code.
When it comes to writing code, we have this entire library of coding standards that we've moved from one project to another. It describes, sometimes in excruciating detail, exactly how we want our code structured, antipatterns, best practices, etc.
On the review side we have invested equally into skills that split up code into readable chunks, take screenshots of any UI changes for quick validation, and a whole battery of tests to ensure that we're not generating slop.
If you were to look at just our development process, you would conclude that we're very lazy engineers. We seldom write code by hand, we seldom ask for corrections and our reviews are more of a cursory look at the PR rather than a deep review.
But the real work is not in the "development layer", it's now in the "agent layer". Making sure the agent knows how to write solid code so we don't need to write code by hand, making sure it doesn't make dumb mistakes so we don't have to correct it, and structuring our review process in such a way where an engineer only has to take a cursory look at the code.
The key difference we noticed between the "old way" and the "new way" is the "new way" is way more scalable and we're able to move way faster than we ever could before.
But do the people still understand what the system is doing and why?
You can have code that perfectly follows every standard and passes every test while gradually building a system nobody has a mental model of.
> an engineer only has to take a cursory look at the code
If that means you’ve automated away checking syntax and implementation, great. But we already had that before. If it means nobody needs to understand the change anymore, then this is exactly the risk I'm talking about in the article.
I'm seeing a bad pattern of vibeslop being used to solve the immediate complaint of the user without stepping back and reconsidering things from a product perspective. Just add another conditional statement to make this very specific scenario the user complained about work the way they want.
It's much easier for people to pump out absolute garbage, you know the kind of "just get it done fast" slop that management types cry out for. And then they wonder why everything end ups broken, not being maintained etc.
And I think the contrast between good and bad code output is much more impactful. Someone can pump out 10x the bad code they used to before, never test it never read through it just push push push baby. And then for good code, sure it's increased my output for slop tasks like repetitive unit tests, but a lot of TLC and review is required for good code and I'd say I've had maybe a 2-3x speed up on a lot of things. But not 10x; you only get that when you don't give a fuck.
I am just tired of typing and looking up syntax for every line of code.
This, however, is a slippery slope, and one has to be mindful of falling into cognitive surrender.
Were you only relying on the difficulty of producing "working" from replacement skill/rate "software engineers" and their level of disinterest being the only real circuit breaker?
This isn't coming solely from engineers wanting to produce more stuff faster.
Generative AI breaks that agreement. It took me over a year to realize my previous CTO actually didn’t care too much about the system design he shipped . And the expectation was actually to just throw it away, have AI reimplement “what wasn’t working”. Use AI to ship, AI to learn what shipped, and AI to fix what shipped.
I quit because of it. Hell is working on other people’s AI code.
> Hell is working on other people's NoSQL code.
> Hell is working on other people's Python slop code.
> Hell is working on other people's enterprise Java code.
> Hell is working on other people's Windows Forms/GUI Builder code.
To quote Jean-Paul Sartre: Hell is other people.
In general, the way we still do it is: some basic static analysis finding anti-patterns, but the meat of it is, and always will be, code review. Except you can't review code at the pace AI generates it.
Where I work someone is still responsible for the output. We expect developers to examine the code the LLM produces before burdening someone else with it.
We had tests, CI, code review, QA, architectural reviews, etc. None of those disappeared. But they were designed for a world where producing such a large amount of change was impossible.
Tests don’t solve that. Tests can tell you that the behaviours you thought to test still work. How many times have you had a completely green CI with 100% coverage and still shipped a bug?
It seems pretty clear that the current crop of executives strongly prefer the latter scenario.
Yeah, that sure sounds like paperclip maximizing hypercapitalists. Real big on sharing, not so big on minding the cost, but they just can't show their love for us all while employee labor still has some value to them. Once that's out of the way and they've taken or mulched everything of value from others, that's... that's when they'll start giving it all back, yeah.
I know the sarcasm isn't helpful. But goddamn I can't understand this take, I don't know why people believe people-shaped entities like [your favorite wealthy sociopath's name here] will become society's mommy if given the power, and it's incredibly fscking frustrating. Like people who think once their home and everything is burned to the ground, the fire will rebuild everything, but better.
So yes, garbage in -> garbage out, but framed in a way that makes it clear what is garbage. The ideas, not the engineer themselves :-)
This suggests we need to be doing more designing and planning; introducing that friction intentionally to make sure bad ideas get culled, viable ideas get refined. Critical thinking becomes the bottleneck; the quality of the idea becomes the deciding factor in success.
> With AI, "bad" engineers can now amplify their "bad" engineering x10 across the organization.
Yup, and that's going to be the comeuppance for a decade of aggresive overhiring.
There are so many "bad engineers" filling the ranks now that in many teams and divisions there's not even anyone left around who can recognize them as such.
This was already manifesting as a rapid decline in software quality and worsening practices, and the amplification effect of AI is mostly going to make everything worse for a while as we wait for all these declining projects to buckle under their weight.
If you are a good engineer, it's a good time to work on small teams with other good engineers and rigorous practices. You can be using AI to amplify what you do (and probably should), but you need to be rigorously considering your processes and guarding yourself from seduction by blind-leading-blind hype you see on social media or in iconference talks.
>>a rapid decline in software quality
It's hard to expect anything else if budget for QA teams is reallocated to cover llm bills.
Hopefully when there's bad devs, there's a bit less making a mess where someone doesn't know better and as a result some amount of average or general best practices start happening.
This can be true not just for software development, but making a mess in anything, including a spreadsheet.
This is where the quality magnification seems to be occurring.
Goal-driven loops can make good code great, or bad code worse.
But, right now I'm paralyzed with fear in how to make a successful career switch without starting from literally "new grad level." I have wisdom, so it doesn't feel like I should have to start at the bottom rung again. Egotistically, I don't even mind, it's just the salary hit that would be the main issue.
Maybe it's not even a paradigm shift (though, I've always wanted to work on film productions). I've sort of lost the passion for being an IC, but how can I make a transition to management without any management experience? Should I just apply for a managerial role and in the cover letter state management is my intended path for growth?
This is whare I am right now. Even senior positions have dropped 50-60K in range so I've effectively priced myself out of a lateral move because I would be taking a massive hit in salary for the same role I'm doing now. I'm currently at a company that continues to lay people off in lieu of offshore talent and AI. I'm stuck in a weird state of purgatory.
>> Should I just apply for a managerial role and in the cover letter state management is my intended path for growth?
I know many of my friends in senior dev roles have put their resume in Claude and said they were interested in moving into a management role and had Claude revamp their resume into something that was more management focused. Three of them were hired quite quickly not only based on their dev backgrounds with mentoring, training and light management of junior devs, but having enough emerging AI skills they said helped them close the deal.
It just seems like there’s a reckoning coming for our field. I’m going to keep doing it, I don’t see any other choice right now.
i think i fall into this bucket. our "leaders" and executives have told us they dont care about 'shipping good' . we are simply responding to incentives.
This was already happening before. But now, a lot more companies that previously might have taken many years to reach an unmaintainable state can now get there in just a few months.
Prove who's good and bad.
And you can't really, because there's always tradeoffs you're making as an engineer. The really self confident ones think their tradeoffs win, and maybe they do, though often they don't and these people are just self aggrandizing and stroking their large egos. Are you a better engineer just because you made a big talk and had the confidence to share it with lots of people?
my take is everyone in the industry should read grog-brained developer, & no silver bullet before working as a professional.
the other is a mindset change - the best working code is code that's never written as it doesn't have bugs or suffer technical debt. Agentic coding doesn't solve that. Human taste does, which means our job is to reduce the amount of lines we write. agents etc are useful for the filler or bullshit part of our jobs e.g generating tests.
but ultimately I think the whole spec-driven development & agents spitting 100000s of lines era will be looked upon as mass psychosis.
last thing to give an analogy - you don't carve a David statue by gluing together pieces of marble - but you carve it by cutting pieces of a huge block of marble.
I'm having the impression business decisions always win, time is always reduced and requirements always changed half-way during a project, having a much greater impact than any bored old engineer.
I wouldn't be so quick to judge the long tenured engineers. They probably realized that moving business forward is more important than writing artisan code.
You always have some young hotshot who comes in and wants to rewrite your old boring Java monolith into a micro services disaster for "better architecture".
The greybeards learned the life lessons the hard way.
The other aspect to consider is this: stay in this industry long enough and it will beat the soul out of you.
All those smart people are probably using genAI to generate their codebases.
So far, that does not seem to have resulted in a robust, stable system.
Certainly no better than the results the hyperscalers got doing things by hand, and arguably worse.
I remember people used to debate all the time about if there were "10x" engineers or whatever. A few I'm sure, but I think the real problem is we have a lot of 0.1x engineers or worse.
I think the industry highly skewed towards the former back in the 90s (and earlier!) when I first entered it. There certainly were vast differences between the best and the worst, but nothing like the gigantic gulf there is today between say a competent kernel driver developer who can get code mainstreamed into Linux vs. a boot camp style disinterested frontend dev who leet coded and brute forced themselves into a FAANG job.
Working closely with other white collar “generic” jobs and the folks who just show up each day and are not interested in the fundamentals at all make me believe this is kind of the baseline for most industries.
Most folks are in it for the money and are happy to just be good enough to not be fired. Since most middle management is utterly incompetent at performance management the results tend to not be great for pretty much the entire corporate white collar industries. A stellar manager though really stands out in such situations, but they are so rare many won’t work for or with one their entire career.
And most businesses aren’t managed in a way that’s interested in adapting to the microshapes of personnel.
They've been replaced by Markdown files asking Claude to burn tokens on doing something deterministic tools already do faster and better, like checking variable names for typoes (I wish I was making this up).
-John Cook
And more directly, I believe good software engineering is really hard. I think it takes a certain mindset to begin with that many people just do not and will never possess, and it takes years of experience to get a good sense of what works and what doesn't, especially with respect to the entire relationship between code, business, people and teams. Yet we constantly see all this devaluation of the practice of software engineering ("code was always the easy part" - bull-fucking-shit), often times by our own practitioners of the craft.
Management types really really really loathe software developers for making good money, and have spent decades now jumping at any advertisement that suggests it can undercut the salary of your current crop of engineers.
Devaluing software developers has always been the point. Whether you take the cynical view of "They resent us for being expensive" or the apathetic view of "Capitalism simply wants to eliminate any and every cost by definition"
Of course. I bet you loathe having to spend $70,000 to buy a nice car, too!
> Capitalism simply wants to eliminate any and every cost by definition
You could look up what life was like under Soviet communism. Me, I prefer capitalism.
Advances in computing can not be pinned just to planned economy/capitalist economy. For example the West Germany computer industry, French computer industry, UK computer industry (with exception of ARM), Japanese computer industry have fallen behind.
For one, the industry never did professionalize to begin with, certainly not in the way accountants, lawyers etc did. We never had any real body that could certify proficiency, which is what contributed to companies having to resort to leetcode and other such styles of interviewing.
Additionally, it wasn't software engineers doing this, but people looking to cash in on students looking to get a 6-figure job. They were business people, not software engineers.
Good!
> having to resort to leetcode and other such styles of interviewing
Such test filter out the obvious frauds.
if you need garbage like leetcode to filter out "obvious frauds" you got a whole lot of problems in your company/team/...
He did so. He aced the test. He got the job with a huge offer. He agreed that the ROI was out of the park!
P.S. I'm curious what your test is for obvious frauds?
...and everybody clapped?
I have news for you: passing an online leetcode is now so easy that an AI can do it. If you think you're catching the cheaters, you're just wrong.
Leetcode was always a stupid test of competence, but it was cheap and it had a high true-negative rate, which filtered the riff-raff. That isn't true anymore.
Man, there are times when I really hate this industry.
Or as I'd like to call it - Wednesday :)
I'm sorry, but if I'm doing the hiring, the person who isn't willing to come on site to do an interview will be one of the first people off the list to hire (I mean, unless it is a remote job, and the person is nowhere near the employer, obvious exceptions would apply).
In-person interviewing can be extremely valuable. Will it filter out every bad candidate? No, some people excel at faking it. However it can be a big help in finding a good candidate.
Nobody said anything about not coming on site. That's how we used to do it, in the ancient pre-history of 2019. What I said was that if you bring someone on site only to leetcode them, you deserve not to hire anyone.
The downside, of course, is that you don't have the cheap, dumb pre-filter of a memorization test anymore, so you'll have to figure out a better way to winnow down the applicant pool whom you're willing to pay to bring on site.
Maybe finally software engineering will achieve a level of interview maturity seen in other professional fields...but I doubt it.
So this is a new presentation of an old problem, I guess is the takeaway there.
A dice throw and some chitchat would be better recruiting.
Then universities dropped the SAT requirements. Even MIT was suckered into dropping them. It was a disaster. It turns out the SATs were a very strong predictor of college success. MIT and others reinstated the SATs.
- you can take it ~3 times and most colleges will give you the best score without penalty
- you can use your result to apply as many times as you want
- if you feel stuck you can still get a good score by moving on to the other problems
- it's administered uniformly across the world
- you don't need to narrate your thinking while you're still processing information
- you get an objective score instead of a pass/fail that may be subjectiveAlso, if someone is unwilling to do the work to pass the leetcode test, they likely don't have the ambition to get the high pressure jobs.
If the bar is that low, just use an accredited degree, certification, references, or a proctored quiz with questions like "define a linked list in < 3 sentences," and it would be just as effective at filtering the very lowest, while more pleasant for everyone involved and maybe cheaper. Crammable puzzles that don't represent real software engineering don't provide much more value than those filters would.
What absolute drivel. I've done plenty of leetcodes. I don't care about writing a qsort algorithm, I know the trade-offs, unless you're working for a FAANG or FAANG-adjacent company, the need to write your own sorting algorithm implementation is probably zero or near zero.
That wasn't the point. Would you wash your car before picking up your date for the first time? A dirty car would drive just as well, but your date will figure you don't care about the date going well.
(Edit: Perhaps I should have written in my original comment: I'm nobody's code-producing monkey, I'm not dancing for money or peanuts)
Your friend would have spent three weeks practicing their sketching, right? And they would have made a decent drawing at the interview. And that would have the exact same ROI as spending those weeks on practicing leetcode.
The point is not that studying leetcode is good ROI. The point is that large orgs are testing for something that isn't relevant to commercial coding.
This is classic Streetlight Effect [0]. Just because it's easy to test leetcode, and it appears to have something vaguely to do with coding, it gets used.
Like I said in other posts, I would use the "pick a bug and fix it" method. But I'd also screen down from 100 candidates to ~20 or so before getting into technical interviews.
And, again, I don't think leetcode will scale well to 100 interviews either. You need technical staff in that interview room, and if you subject your team to 100 technical interviews using leetcode they're not going to be happy about it.
I interview them and ask questions! Seems good so far.
Exactly what we do on day-to-day basis is what we do when we are trying to grow the team. I would guess that 85% of my team would fail leetcode-style screening right now (which is good cause it is garbage)
After they rejected me I had to point out that their test is selecting for the cheaters.
When you check in at the airport, the machine asks you to certify you are not carrying banned items. Of course, one wanting to break the law and carry banned items would certify it. The purpose is that if you get caught with the banned items, and you certified you did not, it's an extra charge they can paste you with.
I know everyone says that, but I really don't think that they do a good job filtering out shitty engineers. I have worked with plenty of incompetent people who managed to get past the leetcode challenge but are wholly unable to do anything useful involving software.
I feel like what leetcode primarily tests is "does this person know how to use a hashmap in a way that you shouldn't actually use it because you lose cache locality", and that's literally all they test.
Generally they are just wanky bullshit from some middle manager’s slightly-incorrect recollection of their first “data structures and algorithms” class, and the solution is almost invariably “use a hashmap” or “use a minheap”, even though the scope of these problems is usually so small that in a real implementation you would probably do in a more naive big-O-unfriendly fashion because constant factors are going to matter more. Let’s ignore the fact that most of the people who are designing these leetcode problems haven’t actually done any actual optimization and optimization is virtually never part of the job you’re interviewing for.
I don’t know what the “correct” way to interview is, but I am fairly certain that the masturbatory leetcode problem is not correct.
The best interview method I've seen is getting the candidate to work for a day or two alongside the team. The second-best was picking a bug from the current repo and working it out together with the candidate, getting them (or in this case, me) to work out why the bug was happening, work out a solution, code up the solution, and commit it back to the repo as a PR.
That doesn't scale - what if you have 100 applicants? The leetcode will narrow down the field.
The "pick a bug and fix it" scales better, though still not to 100 applicants.
Though I'd say putting 100 people through leetcode interviews would still break a talent acquisition process. I've been part of this kind of process before (though with arbitrary code problems not leetcode) and it was hell for the entire team going through it. Nothing got done for weeks while they were dragged into endless tech interviews.
> the solution is almost invariably “use a hashmap” or “use a minheap”
And you wouldn't be wasting your time on candidates who:
1. don't know what a hashmap or minheap is
2. didn't bother to study up before the interview
Sure, but none have been more thoroughly condemned (and correctly) than the idiotic leetcode whiteboard challenges.
> And you wouldn't be wasting your time on candidates who: 1. don't know what a hashmap or minheap is 2. didn't bother to study up before the interview
OR, and hear me out, you actively filter out people who know how stupid these problems are and know that big-O is misleading for a lot of these problems. You're selection-biasing towards people who are going to regurgitate bad answers, and the middle manager conducting the interviews is usually too incompetent to understand what a "constant factor" is.
I've been rejected for jobs specifically because I mention that using a hashmap for these things will likely be slower than a naive implementation, even when the I get the problem "right" in the way that they wanted it.
Now we could argue that I'm a bad candidate in general, but (at the risk of sounding cocky) I likely do understand data structures and algorithms better than most mediocre engineers conducting the interview, but because most engineers are pretty uninspired and have never asked "why" for anything in their lives, they will "correct" me. They will assume that me providing nuance is a lack of understanding on my end.
> A quick check shows that Google, Microsoft, Nvidia, Meta, Apple, Anthropic all do leetcode testing.
Yep, can confirm. I've worked at a FAANG, and they did indeed leetcode testing for the interview. It turns out that big corporations are fully capable of doing stupid things in perpetuity.
After all, would you get on a jetliner piloted by a handsome fellow with a firm handshake who failed to pass all the written tests, but really knows how to fly?
It's not that hard to study the leetcode books. Doesn't the prize of a top shelf salary make it worthwhile? It's a good investment in your career.
My dad flew 23 airplane types - single engine, multi engine, 2 wings, 1 wing, bombers, fighters, jets, and piston engines. In his papers I found some of the written exams he had to pass to get certified to fly them. Just "knowing how to fly" is a good way to get yourself killed.
There was one incident where his F-86 Saber jet had its engine quit. He was faced with the choice of bailing out or gliding back to base. Having passed the written test, he knew how to calculate the best gliding angle, the best velocity, the best configuration of the airplane, took into account the wind, the altitude, and the weight, and figured he could bring the bird in. Which he did, safely.
All that boring stuff that requires study and it has to reside in your brain.
You are arguing two different points here.
I am, generally speaking, reasonably good at the leetcode stuff, because I agree that it’s not that hard to get good at it. As a practical thing for society as it currently is, sure, studying up on the idiotic leetcode stuff is a relatively good investment.
But that pays little bearing on whether leetcode is a good test, and whether it should be something that we are using as a metric. I am arguing that it’s a dumb test and we should stop doing it at a systemic level.
Would you feel differently if you owned the company, and you'd be paying the salary for months for someone who talked a good game but was incompetent?
In your hypothetical the implication is that the leetcode would be effective at removing people who “talked a big game but are incompetent”. I disagree with that.
I could be wrong about leetcode, but for me to realistically engage with your argument would be a tacit agreement with the premise, and I cannot engage with that in good faith.
The secondary challenge in the kitchen (beyond the challenge of hiring someone who'll simply show up when scheduled, ha) is hiring someone who has a genuine interest in cooking as a craft. It's true that being a line cook isn't especially glamorous work, but I absolutely need someone who has enough love for it that they're proud to show off what they can cook when it isn't my menu.
I interviewed someone who made nothing but scrambled eggs, hash browns, and grits, but they were cooked and seasoned to absolute perfection. This individual was one of my slower line cooks starting out, but the fact they had the drive to learn this level of cooking was good enough for me to invest time in them to improve that speed.
I look for the same love for the craft in software. Literally everyone who's worth their salt has something they've worked on that they will happily show off, or some technique (like, e.g., abusing generics to implement monads in Ada and why this is more interesting than the typical approach using interfaces), or some pet data structure (e.g., critical bit trees and what their pathologies look like vis-à-vis hash tables) that they try to shoehorn into everything, or some bit of code they've read (e.g., SQLite and the Tcl interpreter) that left a lasting impression on their practice.
There's a snag though: being worth one's salt only starts at being able to cut code. I need to witness a candidate write about and walk me through that very technical aspect of the craft that they want to show off.
Assessing craft requires interviewers who understand craft, and the literal only reasons I can see for using LeetCode are when the interviewer is themselves not an expert in the domain (perhaps for reasons of scale, among others), the interviewer cannot (or will not) engage in heavily technical conversation with a candidate, or the job is plainly not about writing software that works.
The role of an engineering degree is to teach you the things you should know about engineering. And an engineer should understand data structures and algorithms.
Accountants and lawyers effectively controlled their customers. You can't use accounting or legal work for business purposes without those things coming from licensed practitioners. And they have no other use than to work with regulatory agencies (loosely speaking such as courts, IRS, etc).
If you lock down software development too hard, people will write their own. It's easier to hack something together that solves a specific problem than to write general purpose software that can be sold. And eventually the licensed programmers will break their own rules, for instance by using un-approved computers, languages, and development tools, in order to compete with software smuggled in from overseas.
"Professionalize" is an interesting way to frame this. As Milton Friedman argued, occupational licensure is almost always pursued by the practitioners rather than consumers. The licensing boards are mostly run by practicing lawyers and CPAs, so you have practicing lawyers and CPAs determining who can compete with them. So what you get are cartel-like bodies.
Most people don't know the histories of how these professions came to be what they are today in the US. If you take 15 minutes to read up on it, it leaves little doubt what the intentions are and how much consumers have been screwed.
> We never had any real body that could certify proficiency, which is what contributed to companies having to resort to leetcode and other such styles of interviewing.
Except that basically everyone in the industry knows that leetcode doesn't test real-world proficiency. It's equally dubious to believe that some sort of body (ostensibly run by practicing software developers) would be able to come up with a means to certify proficiency.
Incidentally, many of the outfits "looking to cash in on students looking to get a 6-figure job" placed a heavy emphasis on teaching their students how to interview, not how to be proficient.
Are you happy that the license is much less a license to do the work and much more of a license to hire unlicensed people to do all the work.
And lastly are you happy that private equity can "hire" the licensed professional to hire 100s more unlicensed people to run a huge company with a catchy slogan?
But it's not certain you would even be able to continue to do the job if you botched things in a horrendous fashion. There is precedent for individuals being barred from working in certain industries if it is considered necessary to protect the public, even when those industries are unlicensed. Granted, it is rare and a lot more complicated than where licenses are found, but if you've botched things in a horrendous fashion anything is possible.
> In the Balanced Budget Act of 1997, Congress capped the number of residency positions that Medicare would fund at each teaching hospital at 1996 levels.
https://thehill.com/opinion/healthcare/5550556-residency-cap...
People don't need a government body to tell them to check for credentials. If people care they can ask (I had to give a copy of my degree certificate thingo to my employer a job or two ago, they cared that I was qualified). The whole and only point of mandating licensing is to raise prices for consumers.
EDIT
Just while I'm thinking about it, the law is expected to be easy enough for everyone to follow while simultaneously there is is an absurd legal fiction that only a licensed professional can talk sensibly about the law. It is internally inconsistent that lawyers would require a license.
Much like how you can hire a programmer based on that you think their work is good or they made a lot of money programming, rather than just limiting yourself to the people who went to some fancy university. If you don't feel competent at assessing programmer quality then you can exclusively hire ex-Google or MIT programmers or what have you and pay an absurd premium for the most credentialed US developers. But most people don't need to do that.
Rarely does anybody care. I heard it's useful for safety-critical stuff but have never met anyone who has made use of the designation.
That's not an argument.
> I'm quite happy that doctors and lawyers are licensed.
But you're not happy that you have to pay for 10 years of medical or law school for a broken bone or employment contract.
The government could license a gradient of qualifications to better match skills with services. (as they reluctantly started to do in medicine due to pressure to economize MDs.)
I very much mostly agree with you, but I did take the Google Cloud Associate exam a year and a half ago and honestly it felt like a pretty rigorous exam. I definitely could not have passed that exam if I was incompetent in my knowledge of cloud and IT. Exams like these, I think, might become more mainstream in certifying developers in my opinion. (Though whether this is desirable is another question.)
What could be a generic framework? Do you have any reference to standards?
Yet, both have to have medical degrees in order to be called doctors.
That you specialise after the fact doesn't really mean what you imply, not everyone who becomes a doctor can do brain surgery.
If I can build you a web application as a "web developer" but not "software engineer", you haven't accomplished anything by restricting a title. It's basically certification, similar to the Project Management Professional (PMP) title, which you can only use if you've achieved PMB certification. But people without this certification can still work in project management roles.
- Submarines.[1]
- Homeland Security [2]
Would we be insisting everyone writes bad 90s style OO code because that's the professional standard? How do you have standards when the field is still figuring itself out?
Are we at a stable spot now or am I just overindexing on my personal understanding?
Python and NodeJS are some of your most popular tools and newborn programmers just started checks watch today and don't know what OOP is. They can write hello world if they download 500MB of packages first. Good luck.
Oh look, a new electron app!
Regulatory bodies generally need a raison d’etre to exist (like people will die, or go to jail, if we screw up). They also need to provide clear benefits (to the licensees), like medical practice, or CPA licenses.
I don’t think that ever worked, for software. Companies have been hiring anyone that can spell “algorithm,” for a couple of decades, and making money, hand over fist.
In my case, I’m sort of grateful. I have no “on paper” qualifications (high school dropout, with a GED), yet managed to have a long career, working with some pretty heavy-duty pros.
Most of the dolts I interviewed in the UK had a 6 week bootcamp behind them and called themselves "JavaScript Experts". No joke.
To be fair, there were a bunch of students that did listen and worked hard on their assignments and projects and went on to integrate what they learned into their chosen profession and progressed in their jobs. I was very proud of that bunch.
Surprisingly, I wasn't asked by the organizers to teach again. It also didn't help that midway I was asked to switch from teaching web development to machine learning and they didn't really like it when I said "but those are two very different things".
There is very little innovation going on. And most companies do everything they can to stick to standard patterns, technologies etc where all the risk is removed and known in advance.
Often "good" programmers are worse - they over complicate the architecture, go off on tangents, try to solve problems the business didn't ask for either etc.
So bootcamps filled a need.
This is not any different with offshoring before, and AI now.
because they've been bitten plenty times before by business telling them that certain requirements are not needed, just to be told 2 weeks later that they are...
To me, the difficult parts of software engineering are in the design. That's where you're defining the problem you're trying to solve, picking what technology to build upon, what kind of architecture you're planning on implementing, ruling out what does/doesn't make sense, taking input from stakeholders, and finding the balance between price and performance. Once all that is covered I generally have a good high-level mental map of a system's structure, and actually writing the code to bring those ideas to life truly is the easier part.
That being said, I still believe writing good code is a skill that is only learned through experience/the practice of actually writing code. And that experience is necessary for reviewing code - regardless of whether the code you're reviewing was written by humans or AI.
Kind of like baking. Putting it in the oven was always the easy part. But combining the right ingredients in the right ratios is necessary, and much more difficult than the putting-it-in-the-oven part. And even then, it takes experience to know when something needs to be pulled early or left in longer. Because ovens are non-deterministic.
This is exactly why I became a PM [1]. I wanted to do "harder" things that had bigger scope than I could do as "just an engineer", and the kind of roles that offer that scope within engineering end up being thin on the ground. Unfortunately, what I've generally found is that being a technical PM is a good way to have people try to knife you constantly. Most PMs are technically illiterate MBA types, and carry a deep grudge against anyone who gives the technology any consideration. They're also good at politics, and want you to die. On the other side of the coin, because most PMs are technically illiterate, engineers often instinctively reject you like a tumor. To overcome this, you need to appeal to the technology, which puts more of a target on your back from the other PMs...
Anyway, my point is that this is all very sad, because you're describing is exactly what a PM does -- but with technical competence. And because of the way the industry is structured, the people who can do that either get shuffled into people management, or reach a rapid career ceiling when so-called "architecture" roles aren't available.
There's this pervasive myth that you cannot be good at technology while also prioritizing the business needs, but usually what this really means is that the "business types" bias in one direction exclusively, and treat the technology as the enemy. It's why so many companies are AI-maxxing now -- the promise of replacing the expensive nerds is the eternal flame for the MBA.
[1] well, that, plus after being a founder, people were suddenly willing to hire me to be a PM...
I used to do a lot of interviews in my previous career, and I can't tell you the number of times I'd be interviewing someone who could talk a good game, but the second it got to writing code, if the world depended on them being able to write a simple correct loop, we'd all be dead. I know everyone shits on Lee code, and I agree the "brain teaser-y" nature of it doesn't often match real world development, but often times I'd tell folks almost exactly what the code needed to do, in English, and they still couldn't translate that to sensible code.
Last side note, when this topic comes up I feel some folks are really biking it down to the absurd "typing was never the hard part". Well, yeah, sure. But actually writing correct, maintainable, well-structured code is (was?) very much at least one of the hard parts.
Compared to the other parts. If you can do the problem solving part and the design part,code is easy. If you can't write code, I strongly doubt your ability to do the first two.
People talking good game always try to keep it high level and full of jargon. Once you ask them to explain part of the design, you'll see the inconsistency and holes of what they are saying very easily.
> ovens are non-deterministic
Uhhh… no? Modulo calibration drift, they will get to and hold a commanded temperature for as long as you tell them to. The ambient humidity and temperature in your house / bakery may differ - which can absolutely affect some foods - but ovens are pretty binary.
It's the same behavior around consulting firms, code boot camps, and now AI.
You can learn a new language, in a couple of weeks, if you’re experienced.
But you’re gonna have a heavy accent.
Learning the language without an accent, takes years, no matter how good you are.
There’s always stories of apocryphal John Henry types, but I’ve never actually met one, and I’ve worked with some pretty sharp characters.
Why? While the rest of your comment explains why the plan failed, it seems like it should be pretty obvious why business would try to attract an increased supply. Hint: It puts downward pressure on price. Same reason they are trying again with AI.
> every other job I can think of at a similar salary level has entrance requirements'
Yes, the artificial restrictions on supply is how those careers have similar salaries. Other occupations moved to have restrictions so that they could have high salaries. Software never felt the need to do the same because the natural market propped up salaries just the same, but we'll see how long that lasts now before software practitioners panic and clammer for restrictions to prop salaries back up like the others. AI does actually seem to be making inroads where "learn to code" failed.
Granted, like as suggested at the top of this, the upper class of software engineers who have the necessary reputation and prestige to drive software towards being a licensed profession are not feeling the same pinch that the middle class is feeling, so that is going to make it hard to see restrictions come to fruition even now. When the upper class of software engineers start becoming afraid of shrinking incomes, that's when software engineering will start needing a license.
You say it like it's a bad thing.
About occupational licensing for software: it's also a uniquely global market, so I'm not sure how any one economy moving ahead with occupational licensing would work, unless they also restricted what software you can import or use in the cloud.
Relatively easily, tbh. Just create a regulation that requires either the country's standards or equivalent ones to be used in the creation of any software sold to people/businesses in the country/region.
But standards are always going to be slow to react. Even in mature industries like construction the standards are still trying to find completeness. The standards today are way different than they were a decade ago and they'll be way different ten years from now.
And building construction is something that we've been doing for almost as long as humans have existed. Those standards have been built up over centuries and millennia. Software is gaining some maturity, but still a young pup in the grand scheme of things, so it hasn't had much time to even get through the easy standards.
What to you suggests it is said as a bad thing? It reads neutrally to me.
It's the great strength of software engineering as a profession that formal barriers to entry are so low.
You are right that good engineering is hard, and many people who went to these bootcamps didn't make it. But that doesn't mean we need more bureaucracy and paperwork to keep people out.
Any profession with scammers, con artists, and snake-oil sellers?
Whenever I've used this phrase or seen other people use this phrase it's never been in the context of software engineering. It's always been in the context of literally just spitting out code that a compiler will accept. Believe it or not, a lot of students in CS cohorts have significant struggles fighting the compiler because they just don't understand the language they're programming in and are slow to become proficient (if they ever do). Thus, a lot of people have this idea that writing code, and I mean literally just spitting out something that compiles and runs is hard.
Doing that is indeed quite easy today. That's what we mean by "coding was always the easy part".
Writing code that actually scales into something bigger and is constructed in a way that meets requirements and is flexible? That's a whole different ball game. That's software engineering.
It really is, if there's one sentiment that's remained consistent in me over time it's awe at how harsh of a mistress software is. As good as coding agents are, it still routinely dismantles them in astonishing ways. It's like complexity is the natural state to which all systems want to settle.
Increasingly I am of the opinion that software engineering aught to be a licensed profession, similar to civil engineers, medical professionals, or lawyers. A board of peers to hold you accountable and a licence that can be revoked at any time. Additionally, legislation could be written to require such licensed individuals in safety critical roles.
I suspect the debate around AI assistance tools would be quite different if there was greater accountability for programmers and a constant threat of losing a licence.
If you brick millions of machines impacting hospitals and airports, you should probably never be trusted to write code again.
https://en.wikipedia.org/wiki/2024_CrowdStrike-related_IT_ou...
Only in certain industries, where outcomes can hurt people in any way. There's opportunity to engineer software in just about every industry, but I don't think a widget vendor that wants to connect to a WMS should be compelled to hire licensed anything. Of course, licensed engineers should cost more too.
Civil engineering or medicine is hardly a desirable career model to follow.
Btw doctors make mistakes that kill people all the time. It’s a top 3 cause of death in the US AND they often keep their jobs.
Yes, but they make a lot FEWER such mistakes than would people who could not pass the exams and maintain a license.
The standard is not perfection; the standard is as good as practical and better than if nothing were done. Medical licensing definitely meets both of those criteria. Unless you are arguing that anyone who takes a ten-week "Medical Bootcamp" is ready to be a surgeon you would trust to operate on you or your children?
Would you also be happy to commute to work over a bridge designed by someone with a 10-wk bootcamp in civil engineering?
You have it exactly backwards — Credentialing RAISES the skill floor. It does not raise it to perfection, and "Certificates" in the computing industry are a joke, but real medical or engineering credentials certainly raise the floor higher than the software floor
I don’t know if that’s true. More schooling does not mean more trustworthy or careful doctors. And I suspect some negative trait selection.
Milton Friedman wrote a PhD dissertation on the topic of medicine that I invite you to take a look at.
> than if nothing were done.
The alternative is not to invite people who have no experience to build bridges or perform surgeries.
There are no credentials to work at Google. But you’ll find very skilled and capable people running large projects.
Investors want capable people. Those people are vetted through their reputation in their professional circles.
> Would you also be happy to commute to work over a bridge designed by someone with a 10-wk bootcamp in civil engineering?
No. But I would like to drive over bridges from people with 30 years of bridge building experience over a 4-7 year degree.
If you live in Europe you drive over bridges built without credentials all the time.
> Credentialing RAISES the skill floor.
Correct. That’s my mistake.
The point is if cut off the bottom 20th percentile the field doesn’t get much better. Those people aren’t trusted leaders anyway.
You do however lose a significant amount of upside. Including countless top performers from non traditional backgrounds, which is characteristic of computer hackers.
You can maybe argue that the general public, unlike a corporation is not capable of vetting their own doctor, so the government classified those options for them. And that’s reasonable. But that does not apply at all to software engineers who don’t solicit public work.
I have all the traditional credentials and this is not a projection of my own career.
You state this so confidently, like every person who walks through the door to interview will be 100% honest about their level of experience.
Have you ever interviewed? Nobody _wants_ a software engineer on their team who is awful.
Sometimes they slip through the cracks for a variety of reasons.
How do you think companies hire for key roles like CEOs?
Hardware technology jobs have some of these credentials and are part of that system.
The same as in other regulated professions. It would give the people on the front line who can see the consequences of the corner cutting an effective right to say "No, we're not doing this user hostile thing". This would be a significant barrier because it wouldn't be legal to ship software without the required professional approval and the professionals would be heavily incentivised not to sign off any corner cutting because they would be personally and professionally responsible for any adverse consequences if they did.
What actually happens is that you as an engineer become paid to frame the desired leadership goals in compliant terms.
It’s similar to how lawyers and regulatory compliance rarely change the product. They change how the product is talked about and framed for the purpose of regulation.
This skill among engineers is highly sought after in large companies with political organizations and greater encouraging it changes the composition of the workforce.
Top civil engineers don’t design buildings.
It really depends on the status of the profession in society and the company. I'd expect lots of software organisations to fire a bunch of people looking for people pleasers until this becomes an accepted part of the business approach.
No doubt. Imposing this kind of professional standards to regulate an industry as rich as tech would never work unless the penalties for cutting corners involved making the offending organisations significantly less rich very quickly. They would need to be taught a very clear lesson that hiring people pleasers had become an expensive mistake.
As I commented elsewhere - the problem then becomes who gets to define what the proper path is. For example destroying companies because they chose not to follow the latest sage advice from anyone who once signed the Agile Manifesto does not seem like a good way to promote better quality software to me. And yet it seems highly likely that those are the kinds of people who would initially be engaged as "experts" by those seeking to establish the regulatory environment.
I don't want people like them. I want the quiet, unassuming developer you've never heard of because they're the principal engineer of a team you've also never heard of that has been developing life saving medical equipment without a single significant failure in a live environment for the 15 years since their first device went into use at a local hospital. Get me those people to write the rules - starting with what is acceptable practice when developing software that really needs to work and letting the people who know how to achieve the most challenging results figure out how to tone everything down for applications where imperfections might be more acceptable - and then we can talk about whether regulating software development effectively is now a viable proposition.
This is why any such regulation is likely to end up in a much better state if it's driven by actual practitioners. However, given how many software people are wildly against this, it seems unlikely to happen and so we'll end up in the less good state you note above.
That’s not what I said,
For every human activity there is an underlying reality and there is a social component of how it’s framed or talked about.
Regulatory compliance is 90% social and 10% reality.
So a focus on compliance means engineers spend less of their time on reality.
> They won't be impressed at all by someone's big title and even bigger budget while they're exercising that professional judgement either
Correct. But they do care about their management chain.
Imagine a new grad telling their boss “we aren’t going to build it like that because I learned X in school”. They have the same credentials!
Again our experiences are on opposite ends of the spectrum. For safety issues in particular getting an engineer to sign off some plan when they will be accountable for that authority later is often easiest if you simply design the thing properly.
I have certainly seen compliance become a box-ticking exercise in other contexts but usually this seems to happen when the professionals involved were not personally responsible for their own decisions.
Imagine a new grad telling their boss “we aren’t going to build it like that because I learned X in school”. They have the same credentials!
We appear to live in different realities on this one too. In my reality new grads are not the people signing off major decisions in regulated industries and no-one would seriously suggest that a new grad's degree was an equivalent credential to the years of demonstrable professional experience and peer review that are typically required to reach a level of professional qualification where someone does have the authority to sign off those big decisions. Getting an undergraduate degree in a subject like engineering or medicine or law is just a foot in the door. The real work starts afterwards.
> For safety issues in particular getting an engineer to sign off some plan when they will be accountable for that authority later is often easiest if you simply design the thing properly.
That's exactly right. An engineer aims to build a safe and reliable product (not because the credentials tell him to)! The regulatory myth is that all products are death machines until being redeemed.
That's why I say it's 90% social. The engineer builds a reasonable product. With regulation they do the same, but now they need to do work to frame that same work in regulatory terms.
Real fixes are made. The value isn't 0, but it comes at that cost.
> no-one would seriously suggest that a new grad's degree was an equivalent credential to the years of demonstrable professional experience
That's exactly what I'm saying! Professional experience and reputation within the field is what:
1. gives someone influence and credibility. 2. results in safe and reliable engineering projects.
And note that those are actually informal defined qualifications. It's NOT the credential!
So trying to add credentials to software is an attempt to bump the quality of new grads and has little to no impact on the quality of engineering leadership. As you said, the recent undergrads already lack power and influence, and the credential is simply the bare minimum to participate.
This is true, and basically what tends to happen is that if the Head of some compliance function (e.g. internal audit) is causing problems for the business, then they are replaced with someone who won't cause such problems.
It's still better than nothing. Like, software basically runs our society now, so either software professionals get together on this, or regulations will be imposed on us, and they will be much worse than what we'd get in the first option.
Once again the alternative is not nothing. The most important factor is that they are stakeholders in a project with influence. That is the reality right now, even without credentials.
Can you help me understand what the alternative is?
And I think both are false.
The top engineers on a project are collaborators with leaders in other areas like marketing, sales, IT, legal, etc. And all those have influence on a project. A business person who says “fuck what my engineer says” is not a good leader and won’t have that group’s trust or support. They all want to work together.
So by that process engineering has a seat of influence.
That exists without credentials, and credentials are not what gets you in that seat. Reputation and experience are.
Business leaders don’t do everything engineering says. They also don’t do everything the lawyers say! And having an additional legal backing would change some of these engineering conversation, but not fundamentally.
You glibly say "More schooling does not mean more trustworthy or careful doctors.". Yet the schooling and credentialing clearly cuts off huge numbers of would-be doctors who never pass the exams, never graduate med school, or never even get into med school, or decide it is too difficult in the first place. In the software realm, those people just go to some boot camp and they're off to the races...
Another huge aspect of credentialing is required ongoing education, which REQUIRES physicians and engineers to take updated continuing education just to maintain their license. This again continuously improves the talent pool.
And, if your main concern is that they be "more trustworthy or careful", credentialing also helps that by finding the worst, least trustworthy and careful and cancelling their license, so they are NOT doctors anymore. The untrustworthy or careless SWE just gets a new job to ruin stuff elsewhere, probably taking one from the actual good engineer because their talent is not engineering, but bullshitting.
I disagree to the extent to which this is real leverage. It changes the language and approach, but not the outcome, Ask a civil engineer the degree to which they can fight their leadership on these grounds.
> clearly cuts off huge numbers of would-be doctors who never pass the exams
Yes the fallacy is that more exclusive is better. You don’t understand the traits you select for.
> those people just go to some boot camp and they're off to the races
I don’t see any kids who just got off a boot camp running large software projects. Does this happen at your workplace? Why not?
> This again continuously improves the talent pool.
I just disagree to the extent to which the talent actually increases.
The people who excel already learn and study all time.
This slightly raises the floor by forcing the least curious person to be exposed to some PowerPoints and videos.
> The untrustworthy or careless SWE just gets a new job to ruin stuff elsewhere
They can only ruin the extent of responsibility and scope given to a new hire with no reputation.
> least trustworthy and careful and cancelling their license
Once again you assume the system works as stated. I think it actually selects against those who are bad at avoiding responsibility and not legally savvy.
The image that comes to mind is someone who made a mistake, cares a ton about medicine, and hates the organizational administration.
>>Ask a civil engineer the degree to which they can fight their leadership on these grounds. Both civil engineers and doctors both can and absolutely do refuse to sign off on unsafe situations.
That does not mean they detect them 100% of the time, or never cave to pressure, but they absolutely do. We just never hear about the incidents that didn't happen because a doctor or engineer forced the right solution or no action — precisely because nothing newsworthy happened. We DO hear about the ones that did happen, Therac-25, Mars Climate Orbiter loss, Cloudflare outage, it is endless
>>I think it actually selects against those who are bad at avoiding responsibility and not legally savvy.
You might think that, but clearly you have never read even the summaries of cases where doctors lost their licenses. Hint: it was not some mistake that could have been covered up by better schmoozing. If anything, the system is too lenient.
The rest isn't even worth the bytes to respond; just handwaving an attitude. There are very good arguments to not have licensing on software engineering but you are not making them
I noticed from your response that you didn’t really refute the claims, but that suggesting that systems don’t achieve their stated goal gives you a distasteful feeling.
> We just never hear about the incidents that didn't happen because a doctor or engineer forced the right solution or no action
And the same is true of software. I and my peers tell my bosses ideas are bad all the time. We don’t need a credential to do that. And the credential is not what gave us trust with that decision maker.
> If anything, the system is too lenient.
Correct. Bad doctors continue to keep their jobs all their time.
So that’s my point. What is the criteria that distinguishes those cases? Both doctors made a medical error. Which one gets off and which one gets fired? The doctor who is more focused on medicine is likely the one less skilled at navigating the legal problem.
The doctors making mistakes and keeping their jobs are a pathological minority that is reinforced by their credential giving them authority to operate.
The medical boards are well aware of this, which is why the standards are far more than just about having more schooling.
I am familiar with Friendman's dissertation, and while the economic claims it makes are solid, it isn't a take down about the medical impact of the boards. It really doesn't say one thing or another about them. Let's put it this way: if you are going to inflate the cost of a service, it's hard if the quality of the service is terrible and easily replicated by someone else.
I'll admit I am unsure how such individuals would be chosen. I imagine it would be prudent to learn what processes are used by other licensed professions when choosing such individuals.
> who write lots of blog posts and books about programming and give lots of conference keynotes
I do not think people who write blog posts and give conference keynotes should be awarded with roles that regulate the profession because they write blog posts and give keynotes. I would hope that any regulation is evidence driven.
Have you found existing regulation in any field that's evidence-driven?
My impression is that regulation is not made in a way that has much to do with evidence, but I would be delighted to be shown evidence I'm wrong.
It's hardly a perfect system, but the problem is mostly that it's too conservative and risk aware, making it difficult to impossible to innovate and ignoring the risk this creates. (The world's most popular light aircraft is the 1950s-vintage Cessna 172, mostly because it's impossibly slow and costly to get a reasonably priced modern competitor certified.)
Plenty of regulations in many many fields are evidence based.
Sure, many are not.
But to make such a blanket statement is absurd.
Licensing organizations disproportionately attract people who enjoy "administrating" over "doing."
What kind of data will they look towards? Here, we have a precedent from frantically points to absolutely everywhere around us. So the people with "engagement" and "reputation", i.e. they gushed on their blog and farmed engagement, will be exactly who gets appointed to make the decisions.
Bring a software engineer into a courtroom as an expert witness, and the jury's eyes will glaze over. Bring in the PE who told their firm not to cut that corner, and the hammer comes down hard.
Even if the certification for software engineers starts as barebones as knowing what WASP is, it still provides an avenue for the feedback mechanism to work (the rules "written in blood"), so that the entire industry can study and learn from what happened, instead of this mess we have now, the peak of which is postmortem blog posts. Even now we have plenty of examples of regulatory frameworks where the regulations adapt to the field like the FDA where you've got a huge spectrum ranging from diagnostics to medical devices of which where are many classes, and drugs where every clinical trial can be tailored to the exact nature of the disease.
The problem for regulating software development is still who gets to formally determine who the "good" people are. This kind of thing should clearly be objective and evidence-based but what useful evidence do we have available?
In physical engineering disciplines there are often clearly evident problems if something was built without being adequately specified by the responsible engineers. In a disastrous case a bridge might literally fall down but you're also going to see that a bridge wasn't designed properly if it's distorting in ways it shouldn't under loads that it should be able to support. There are lots of experienced engineers who have proven records specifying buildings or planes or ships that need to not break using established and peer reviewed techniques.
In software we can all agree catastrophic failures that result in loss of life or half the Internet going down are obviously bad. For something controlling a life-saving medical device or the launch authorisation system for the nuclear missiles we can probably all agree that the answer to what quality level we want in the software is "the best quality we can achieve". But those systems have unusually serious consequences if anything ever goes wrong and probably also very high development budgets that can justify such an extreme position on quality. In general we don't have clearly defined levels of software where different trade-offs between cost and risks and other factors might be considered reasonable and acceptable. Nor do we have well tested and universally accepted standards for how to reliably achieve a specified quality level.
There is zero useful evidence because there is no one to collect it.
The Institution of Civil Engineers was founded in 1818, after decades of random civil engineering societies in Britain doing the exact same thing we are now (running around like chickens with their heads cut off). It wasn't until after the ICE's Royal Charter a decade later that civil engineering began to get really systematized into the "real engineering" we know today and that charter effectively established them as a regulatory body that allowed that to happen.
I'm not sure that is entirely true. There have certainly been a few people who have attempted to study what did or didn't work in industrial settings - either pure academics or people working in industrial research labs. But I agree that currently we have nowhere near enough data to form robust conclusions about almost anything in this field and I think this is the strongest argument that the industry is not ready for any kind of licensing and regulation regime.
Those people would be writing the regulations.
Because it isn't creative work. Software underpins payment processors, medical services, emergency alerts, infrastructure. In the UK not long ago a ransomware attack took the healthcare system offline and surgeries had to be postponed. in 2021 the Colonial Pipeline attack took 50% of the US East Coast's oil supply offline. The entire German train system died a few weeks ago for half a day because of a software bug.
People's entire communication is in digital services, all of their private data, the economy grinds to a halt or national security is impacted monthly now by either deliberate attacks or just bugs.
Of course professionals themselves need to be licensed, how else is any company supposed to have any confidence in who they employ or any legal security?
My experience with civil engineers and lawyers is many of them aren't worth spit. Licensing is not a magical cert that proves competence.
BTW, if you hire a lawyer in WA state, be sure to ask if they passed the bar. The state has been licensing lawyers who don't pass it.
The way licensing fundamentally works is industry basically strikes a bargain with government to it's benefit. Government lets the licensing organization run a supply cartel and collect protection money (dues, test fees, whatever) so long as they promise to enforce (low) minimum standards along the way. Government gives licensees favorable treatment in court (statutory limits to liability, licensed professionals opinions are more equal than average peasants, etc, etc), etc. And all this stands so long as they do whatever the government's rules say (to the detriment of the customers). And of course the professionals make money hand over fist (or at least more than they're worth) in the process because the licensing organization constrains supply.
Society gets just enough scraps to provide the political will to get it done and keep it rolling (the low minimum standards).
For instance, a lawyer spends most of their time reading and writing, but no one would ever say "you can read and write? Have a crack on our legal team". It's a particular type of writing, and the writing is really a means to an end. This is a distinction that is lost in software development. Every engineering discipline now learns programming, but the ability to write code shouldn't be a license to write software in the same way that knowing how to read and write doesn't just grant you the ability to join a legal team and start writing contracts.
Direct licensing requirements from the state are prone to abuse via regulatory capture. Big or entrenched players can give to politicians who’ll change the rules in their favor, setting who needs a license and who can get one.
The profit maximizing incentive for insurance is a double edged sword, but if there’s a government backed insurer that just does the prime rate for licensed developers, the commercial market can build off that and fill in the gaps.
If you need a special license and insurance to drive a commercial truck on public roadways, why not the same for commercial traffic on the public internet? A good way to drive adoption from nontechnical folks could be something like the lock icon in the browser for TLS. Issue a domain cert for certified software, you can go to their website and confirm they are compliant right away. People are free to publish and use non-certified apps, they just won’t unless they have a reason to trust them.
Government involvement almost always just makes the problem worse, not better. There is a place for control in some areas (medical, military applications, etc), but I think broad-sweeping regulation would do far more damage than good.
Like sure, if you're writing software for medical professionals, or lawyers, or aviation companies then I can see that being something you'd want people licensed for. A major bug in a pacemaker or plane's autopilot system is a huge deal that could injure or kill a lot of people.
At the same time though, a lot of software engineering/programming work is extremely low stakes, and I think expecting that to be licensed would be kinda ridiculous. Having someone need to be licensed to create a small business WordPress site, or local desktop software to solve a personal need, or most video games in general feels kind of absurd. Do people need to be licensed to make say, Minecraft mods or hack a game from the 80s?
The difference with the legal and medical industry is that if someone is incompetent or screws up in those fields, there are almost certainly going to be negative, if not dire consequences for those involved. If someone screws up in tech, then there may be dire consequences in some industries/sub-fields, or no/positive consequences in others.
So how many people "learned to code" and then ended up back on non-software related careers?
And, as a "Learn to Code" guy who's had a successful and interesting career filled with self-study and continual improvement, I'll call you a gatekeeper.
I've interviewed many bootcamp graduates. You're right. Many of them can't do the job. We don't hire those guys. But that begs the question - what companies are hiring incompetent people?
I don't think this is attributable to the 'learn to code' push; I know many fine engineers who came through boot camps, and many, many poor ones who came in the 'official' way.
The problem is that we trained too many people, many of them without the aptitude, not how we trained them.
At my workplace, the earliest programmers were a combination of self-taught and people with real CS degrees. The CS people wrote the OS and languages for an in house minicomputer. The apps were written by people with app experience, mostly scientists. And there were a few odd characters like the secretary who learned programming because it was quicker to fix bugs herself than get clarification from the engineers.
For a lot of people, they have no need to ship production grade software that scales to babel. But a custom script that solves an immediate business need is a common thing.
I think that aim is more important than the harm learn to code might have caused our profession. And for similar reasons, I feel the agency AI brings to individuals is something that shouldn't be discounted either. No idea what the total calculus on cost benefits turns out to be, but I would hope this benefit is not missed.
For a certain class of professionals, slowness is a kind of superpower able to restrain their damage. LLMs have turned off those guardrails.
On one hand, I'm not fully surprised -- LLMs are powerful tools, but of course they can be misused. On the other hand, I'm impressed by how fast things are deteriorating in some shops. At my job they got encouraged, over-confident even, to finally do some long-awaited major overhaul in the code base. I'm genuinely concerned about our ability to continue maintaining this mess in the mid and long-term.
Blame the patrons for demanding more with little care to the quality.
I mostly gave up on software development roles in business when the vast majority of developers and, particularly management and executives, made clear that they couldn't give a fuck about craftsmanship. It was just about shipping, good, bad or otherwise.
AI in software development predates on that appetite for MORE at any cost. When the business doesn't really care about quality, because, let's be honest, most don't, this is what you get. You get massive volumes of garbage.
That is a problem whenever people do things for money. It suggests that a big problem with our society is people are encouraged (in some cases effectively forced) to want money too much.
To work on engineering real time communications systems, banking systems, or transit systems and low level infrastructure, you definitely need some chops. To design and build out core network infra at the web giants, chops also certainly required.
To build out a basic crud app, pwa, or the next feature in the massive products that major companies ship? Yes you need some understanding but it really isn't that difficult or onerous. TBH if you ask me the profession always had a problem where the term "engineer" was a tad over applied. The boot camps are mostly churning out people who can write basic apps, not (hopefully) anyone being placed into a a senior IC and systems design role.
2010’s was when more traditional CS courses also started moving from traditional languages and content to JS etc…following industry demand.
A lot of tech conferences were pure tech. Now a lot of them are agile, soft skills based, introverted nerds pushed out.
It’s certainly a different place from the 2010’s.
I would also throw in the toxic positivity and gas lighting sorrounding that. We got a lot of churn on "we have to be nice to everyone" and fears that people weren't "being included." I'm not saying you have to go all Linus on everyone, but it really catered to those who didn't want to learn a lot of the details or were resistent to testing their own code.
So unfortunately, for those like me who spent a decade in the trades, saw that it could destroy your body by your 40s and decided I’d like to not have that happen to me the number of exits into knowledge work is shrinking.
I'm not the best person to talk to, because I'm not a salaried programmer for some corporation, and I'm not looking for a job from a startup or something. I'm in a unique position where I wrote a suite of proprietary software that clients pay for that they would have a hard time replicating or migrating away from, even if AI helped them. Lucky me, I happened to get into a specialized industry and start writing code for it 20 years ago, and I kept all the data and code logic in my own silos and never shared anything with anyone. So I am somewhat protected because it would cost 3x more to replace what I wrote than to just pay me for the rest of my life to maintain what I built.
By the way, I started this software in my 20s when my body was already being destroyed by physical jobs. I started it while I was driving a taxi and waiting tables at the same time. I learned by reading books in my cab. I don't think that's an option for people anymore.
My best friend worked for a massive multinational similar to Salesforce and he ran a team of 60 people under him until last year. He was not AI-proof. They laid off everyone on his team except for him and 3 helpers, and told him to use AI to do everything else. After awhile, they laid him off too. After interviewing for a couple months, he found a new job, and his job is to manage two people running AIs. It was a 30% pay cut and he feels lucky to have it.
Under any external hierarchy, where I didn't have this lifetime of private code and clients in my pocket, his job would have been way, way above mine. I would have been one of the 60 people laid off.
Okay, so I'm going to say something about this "knowledge work" thing because I've known a lot of people who took courses and transitioned to it from the trades. Almost all of them did not get decent jobs. One of them was a bartender who just somehow got it. This was around 2018. Her husband works in construction. She just sat down and it clicked, she learned to write javascript in 3 months. I'd sit at her bar and tell her what to improve and she'd write it down and memorize it. In six months she was writing like a native, and she got a job at [huge multinational retail company] working on their website. And somehow she survived round after round of layoffs to keep going and become the only person left on her team. I'm immensely proud of her. And she will still probably lose her job in the next six months.
But my ex-girlfriend tried to learn to code at exactly the same time, and it went nowhere. Just didn't make sense to her.
So that's why I wouldn't recommend it. Honestly, if I didn't have the little pile of code I was sitting on that pays my bills, I would go to school to be a plumber or air conditioning specialist, or to repair helicopters or be a car mechanic. That's basically what I do anyway, I just do it in code instead of parts. At one time, what I did was equivalent to building custom cars and engines, only in code. At this point, fixing a car would be more satisfying. No one's paying to build their hot rod in code anymore, that's all being thrown at AI. And the rest of the jobs suck.
I’m not in it for the money, and that I can make a good (better than most) living from it is just pure luck and I am genuinely thankful.
But there are lots of people in it only for the money, and they will be very disappointed when it dries up, because the #1 thing these bosses want is for us to have less leverage.. They want it even more than they want revenue.
It's similar to why there's hundreds of books about learning the basics of a language, but comparatively few books about good software architecture/design
The vast majority! I think I've come across 1 or 2 competent engineers in 20+ years. It's a miracle that software works, ever. Increasingly, it doesn't.
Meanwhile, software engineering courses taught it as abstractions and algorithms, and electronic engineering taught control flow on bare metal.
No one, it appears, is taught design or system architecture outside the context of operating systems. Even requirements engineer is a rare job title.
As more complexity has fallen into the domain of software, nobody has been given responsibility for it. The way we treat junior developers now would be like expecting a carpenter or bricklayer to figure out building architechure and structural engineering, without formal training.
It's even worse than that. We've got a CEO who has suddenly learned how to vibe code and the stuff he's coming up with is... kind of horrendous. He's coming up with new "products" and proclaiming them the next big thing for us to work on and we're kind of over here scratching our heads asking who would want this? Who would pay for it? I mean, he was able to put together a kind of a cool web app (with 0 web app knowledge) that's supposedly going to let users design thingys with AI, but it just seems like he re-invented a harness/IDE. I suggested that maybe what he wants is a VS Code plugin like Cline or KiloCode... but he hadn't used VS Code.
Oh and he's altering course from the previous "AI only where it makes sense" to "everyone should code, even the sellers" and "AI is not optional, we're an AI first company".
Talk about drinking the Kool-Aid...
We now need to talk about the 10xBad engineer.
I think the real pain though is that AI also often removes the feedback loop between "good" engineers and "bad" engineers. A lot of "good" engineers started as "bad" engineers that learned, sometimes the hard way and sometimes with patient mentorship, how to be better engineers. Patient mentorship becomes harder as code reviews become less personal. "The Hard Way" becomes harder when the consequences get divorced from actions. For a bad engineer it becomes "Claude broke Production" more often than "I broke Production" and learning mostly ceases.
We're starting to recognize how many junior developers AI is replacing, making the pipeline to senior developers harder (if not disappearing), but we also maybe aren't focusing enough on how much we are also losing the pipeline from "bad" to "good" engineers.
Absolutely on point. I just completed the port of a industrial application written in Python using a sophisticated console-based UI to C# and Avalonia UI. This is my second major coding project using Codex.
The one salient element of the experience has been that, as I keep saying to anyone who will listen, AI still does not understand anything it is doing. It presents an amazing simulation of it, but, no, it does not.
Here's a simple example: The original application had a clean communications protocol implementation. A single file with a class that implemented every single command you could have the industrial controller issue to the hardware. Codex was explicitly told to replicate that in C#. It did, at first, but then it started to duplicate command processor code in the individual functional blocks throughout the application. Which means that, when a bug surfaced, you had to fix it in five different places.
Another example: The application has a highly customized table view. Once again, it was told to make that a component to reuse throughout the application. It did, at first, and then weird bugs started to surface that made it clear that it had reimplemented the table control in different areas of the application.
If you don't know what you are doing you will probably not pick-up or even care about some of these things. It is easier to whack-a-mole bugs with AI than to worry about code structure, efficiency, maintainability, future-proofing, scalability, etc.
I purposely decided not to look or touch a single line of code during this project to see what's possible and where the issues might be. I learned a lot and continue to learn. I think the next step is some sort of an agentic approach, maybe using OpenClaw (or whatever, I don't really know right now) to create a team with coding, supervisory and testing agents.
While the project got done significantly faster than it would have without AI (four weeks instead of probably 4 to 6 months), the process was just as intense as coding, just operating at a different level, micromanaging architecture and implementation.
and
> I don't subscribe to the idea that AI generated code is fundamentally bad, just that people lack the right skills today to wrangle agents into writing good code.
those people who lack the right skills today – are they the bad engineers you'd mentioned previously?
This is why I don't have any patience for the people who say "but AI is so powerful! we can do so much!" It amplifies the bad stuff more than the good stuff, so it's a net negative.
I would expand this even further and say that the worst problem for people in the trenches isn't even just that this is happening, it's the it creates a situation where managers are held to some expectations (their team shipping product features) that incentivize not looking too carefully at what their team members are putting out. It makes it really hard to tell a boss "we need to stop and spend a few days reviewing and rewriting because one of my teammates likes to one-shot everything with poorly thought out Claude prompts making multithousand line PRs" when their own bosses are breathing down their neck.
It's the same struggle we face to get refactor work prioritized, just at a much more frequent cadence. "It's working so why do we need to spend another sprint on it?"
I know this happens, but don’t really understand it.
In my experience, quality hits usually resulted from external pressure (bad managers, trade show-driven schedules, etc.). I always wanted to do better.
Now that I’m retired, I take the time to really get Quality right. LLMs have helped (but they need close watching).
Specifically, I’m spending a lot of time on the first few instances of a pattern that I hope to have the AI scale out for me. My thought is that I can provide an opinionated project structure, feel it out myself, then point the AI to those working examples in the future. Until then, I’m mostly just using ai as fancy autocomplete + domain research.
It's actually this that leaves me feeling optimistic. We're definitely bad at this today, but will we always be bad at this into the foreseeable future? I'd like to think not. I'd like to think that we'll get better at working with agents in the future and eventually develop better practices around this new weird technology once it's better understood.
For everyone adding value with LLMs there will be way more destroying value. If you roll a critical failure a mediocre LLM enhanced VP convinces the org to sail aggressively in the wrong direction.
one good swe out of ten with high authority may be enough in most organisation
Which is an incentive problem, they have likely reached an equilibrium with their company. Genuinely few companies provide any incentive and critically, the space, to ship good code.
Because frankly it doesn't matter in the middle grounds. Which is where 90% of developers are.
I wish we all had fulfilling edge of our seat projects to work on, that challenged us just right, mattered to our community etc. AI is absolutely poised to disrupt the middle 80% of development because the middle 80% of dev is not that important or hard.
It's just a shame for all of us who loved the craft, and didn't mind being in the middle making a living. That's a totally noble place to be, and it could get taken away from many of us.
There's different kinds of bad too, some justified. The senior that made their way boot licking and being at the right place and time. The junior that just got there. The senior that does not care anymore for being left out of promo two years ago and having to report to the person they despised as being a bad engineer.
AI isn't making human behavior better. In any way.
Life is too short for all this, keep doing the good stuff, filter in the good, keep the bad out that you can, ignore the rest. Have the self reflection to know when things aren't working out, and when its worth getting out. Build the wisdom to not repeat the same mistakes. Believe that there's a lot of good work to be done in the world and contribute in any way possible.
I've heard some refer to this as a "nature is healing" scenario for the industry where if you only signed up for a high paycheck and didn't care to think critically about any of the work you're doing then this will be painful because that previously manual process has been automated. The floor of what's necessary to be considered valuable has been raised.
This is the theory, but I’ve never worked anywhere (and I’ve worked at a lot of places over 20 years) that actually did it like that in practice.
What tends to happen is that the EMs and PMs look at who’s free and give that person the task. This means that sometimes you get a senior leading a simple project and sometimes you get a junior leading/designing a complex project (usually with help from a very minorly technical PM).
Then the senior/staff/principal (often on a different “special” team) gets pulled in at the last minute to rescue the project.
If your company is highly product driven, you’ll often find that the juniors end up leaving projects more often than not because they will tell the PM exactly what they want to hear.
I've seen a twist - not juniors but just offshore engineers.
Primarily in Silicon Valley or outside of it?
I worked most of my two decades in the Valley but also spent time outside of it. There is in many cases a vast gulf between the dev cultures. What the parent comment is describing I've seen many many times.
I would have said the same thing for the first 15 years of my career across several jobs and acquisitions.
Then I took a job at a company that fit this description. They had so many managers and PMs that every task was talked about, broken down, and documented so much that every Jira ticket was a little piece of work that a junior could handle by Googling things.
The quirk was that they had started hiring a lot of experienced and staff level engineers, too, but then tried to force this same framework on to everyone. We spent more time discussing tasks than doing them by a factor of 2-50X. There are some situations where this is appropriate, but none of our work was actually high scale or difficult. Your day might be spent writing design docs and collective sign offs as you worked through committees until the tickets at the end were so simple that any junior could do them.
It didn’t lead to better software. It was one big cargo cult game of performative management. A frequent outcome was that someone would get into the micromanaged tickets and realize there was a better way to handle something, but it wasn’t worth doing all of the fighting and meetings involved to do the meeting and Jira ticket dance all over again.
Unfortunately, looking back, I could easily see Claude replacing 3 out of 4 of those developers. Myself + one other dev + AI would probably would've shipped a bit more a little faster. With that said tokens aren't free so the net cost savings would've been 2 dev salaries maximum.
We're not too much an AI-friendly company yet, so we don't officially have Claude access, but I can tell with certainty that several of my Indian teammates are using Claude anyway. I'm pretty familiar with the style of code it creates. And the comments are decidedly better English, which is a big giveaway itself.
>What tends to happen is that the EMs and PMs look at who’s free and give that person the task.
The gp you replied to qualified it with "enterprise software" (LOB, CRUD, etc aka "cost center") so your observations where senior -vs- junior engineers being more fungible can be true.
However, in "engineering" type of software products (game engines, RDBMS engines, operating systems, etc) where the software is more often a "product" that's sold (aka profit center) ... there are definitely different layers of complexity where senior and junior engineers are not fungible at all.
One way to describe the differences of complexity and criticality in various parts of the source tree is the "core" parts vs the "leaf" parts. E.g. in a game engine or Linux kernel, the deep parts of the engine or os process scheduler where the tight loops are located are the "core" parts. They most likely would be worked on by the most senior people.
But the game engine may have some less complex code for handling text width on a menu for different foreign languages. Or the os needs a new menu option on the installer to ask for the users age. Those would be more "leaf" functionality in the source tree. A junior could get assigned to those parts with less risk. After a few years of experience, he might be trusted enough to work on the deep "core" logic without screwing things up in catastrophic ways for a million customers.
A product with several million lines of source code will invariably have both the "hard parts" and "easy parts" so the new hires and juniors will work on the easier stuff first.
There's also a spectrum of hard-to-easy in enterprise software but it's much more narrow than engineering code bases.
That's great and all, but that's a small minority of all software written. I'd love to work on projects like that but ultimately I have to pay the bills. Many software engineers are in the same boat I am.
Now I guess I'm just up shit creek because I built a career on SAAS work that was available instead of holding out hope I could get in at my dream job working on game engines or some other non-SAAS product?
Sorry if I sound bitter. I'm variations tired of hearing variations "If you only worked in SAAS you were always close to meaningless and now we've automated you so you don't deserve to earn anything anymore". Feels like every day.
I'm not going to bang this drum too much, because it's been done to death for well over a decade, but lines-of-business supported by CRUD apps are rarely simple from an engineering perspective. Much of that engineering is in the decisions made outside the codebase, or spread across multiple codebases. If you're looking for the one obviously brilliant line of code to tip your fedora to while sipping your snifter of wine, you're not gonna find it. In fact, "clever" code like that is rightfully and instantly rejected as cowboy code.
By your reasoning, civil engineering isn't "real" engineering like aerospace cuz they don't build things that go really really fast and shoot out fire and stuff. Also, there's like too many responsibilities delegated out. Like, man, I only wanna talk to the guys who put the rockets on the thing. Everyone else are just overpaid slackers that smooth talked their way! They're gonna get replaced by AI! Mark my words!
You misread my comment as some dig at CRUD LOB enterprise coders. I used to work on enterprise ERP code with 20000+ tables. Yes, I agree it definitely wasn't simple.
Instead, I was responding to a very specific observation the gp made: he saw that both senior and junior devs were interchangeable when randomly assigning the next JIRA ticket.
That can only happen in a situation where the JIRA tickets are similar enough in complexity that the difference in skills between your senior and junior devs are irrelevant when the work is assigned.
Maybe some enterprise software teams can work like that. However, none of the engineering-heavy type of codebases can treat seniors and juniors interchangeably.
Even before LLMs, the coding tasks were less than 50% of the time spent on all my Jira boards in the past 15 years. It makes perfect sense that they are assigned based on available capacity. By the time the coding begins, it's already too late to worry about implementation.
You're right that small tasks are trivial enough to be assigned to anyone. That's the point. That's how it feels to work on the "good" projects regardless of complexity. Planning a complex project should result in more tasks, not harder tasks. Your epics and stories can sometimes vary in points, but your tasks should not. A primary goal of the planning phase is figuring out how to keep them as low as you can. The points stop being meaningless when you think this way. They tell you where things are too lumpy. You throw more planning time at those lumps.
If assigning to a senior produces better code, you're not spending enough time planning ahead.
That’s not what I was saying.
I was saying that the perception of management is that the tickets are interchangeable. Not that the tickets are actually interchangeable.
Notice what I said after that. That this usually results in seniors coming in at the end to rescue the project.
Same but with 10 years, and I don't think I would do well in a place like that. That removes you from writing code and there is a similar complaint about relying too much on AI and not writing enough code on your own.
Sure you might lean more on Google or SO if it's something you haven't seen before, or it's something deep in a stack that isn't code you actually wrote. But as the noob eventually learns when he thinks he's found a bug in a runtime or compiler that thousands of other people are using every day: No. It's probably your code.
I suppose there are people who never advanced beyond the "type (or copy/paste); run; google the errors" loop, but I've never seen anyone with more than a year or two of experience doing that very often.
I worked in a company where this happened, and it wasn't pretty. Product managers used their experience and seniority to intimidate junior engineers and exert control over project management of engineering projects, which they predictably used to move as much work as possible to post-launch, including testing and security. They also gaslit junior engineers into agreeing that issues with contradictory or impossible product asks could be figured out later, leading to software getting released to customers that fundamentally could not be made reliable, performant, or even secure.
Even after the entire company went on site visits where customers told us they weren't using any of the features released in the last year because they were all buggy, and the only information they wanted about upcoming releases was assurance that their use cases wouldn't be impacted, product still kept claiming that the time it took to release new features was the biggest problem facing the company and kept fighting back against engineers who said we were in a quality crisis and desperately needed to make time for better testing and design.
The only thing that can shield you is good engineering management. Weak management will end up getting rolled by product and start promoting the bad behavior that product insists on. At that company I had a boss whose attitude towards us was "engineers in a startup should make decisions independently and stand by their work" but made sure engineers felt unsafe making engineering decisions that product wasn't happy with, likely because they felt unsafe themselves.
So without a training pipeline to provide experience to jr. Devs, in 15 years we will be hurting for senior devs to replace all the graybeards. Kind of like the fortran crisis of the last decade or so.... Just across an entire industry that supports every other industry....
I’m convinced the only reason there’s a Fortran crisis is because nobody wants to work on Fortran or make a career out of it.
Has nothing to do with willingness to hire juniors. Good luck finding promising juniors who survey their career opportunities and decide that Fortran is a good technology for building their resume.
It's like complaining that no mechanics work on carburetors anymore. Well some do, but they are expensive and not worth it to keep your old hoopty running. Might be worth it if you have a show-quality 1960's era muscle car.
Those people are doomed. Which is fine in a lot of ways, but will be devastating for their economic prospects.
In the same way there is only so much artisan hand crafted furniture to sell, you're a lucky craftsman if you can make a living doing that these days.
I’ve worked with two junior devs recently who are very good precisely because they’re trying to understand what they’re doing, rather than just producing code.
I’ve also worked with senior devs who basically gave up and stopped trying to understand the code. They became much worse engineers as a result. At this point I would much rather work with those 2 juniors.
They use it to explore things they don’t understand, ask me questions to clarify their reasoning, double-check assumptions. They generally use the tools available to increase their understanding.
Think about all the open source the world got from some random person in Finland or Sicily or wherever hacking on a cool idea. Will that still happen with a high (for someone who is not employed... maybe a student) monthly cost?
The way the industry "solved" it was basically raising degree requirements across the board. I went to a top 5 engineering school and one of my undergrad roommates was a mechanical engineer. I remember having a pretty eye-opening conversation with him about how their undergrad program just teaches them what is already commoditized in CAD application packages and is considered table stakes. Industry hires had MS minimums, and plenty of MechEs ended up getting PhDs so they could work on more cutting edge stuff.
My guess is software will end up similarly. The bottom end of this stuff will become purely commoditized and cutting edge stuff will require more education.
I wonder if there's an agent harness that would work well for requirements gathering.
"What can this user see" has always been a very complex question in every crud app I've worked on.
I have worked in startups before and currently work at bkng, and have friends at uber. Everywhere it is expected that the engineers will create their own tickets and refine them with the team. If you are in a product facing team, your PM could even help you with a PRD but I have not seen one in the last few years.
Tickets came from the product side, after being evaluated and prioritized. Engineers got involved with estimating effort (in "points") and doing the actual implementation of course.
usually in most when engineers tend to create their own tickets - it's for useless shit like improve x, clean up y etc.
very few people have worked in places with high agency - where you work with a higher up & create a feature/product line that has customer impact. startups are one of the few places I can think of with high agency.
I wish this were the extent of it nowadays. But for whatever reason, I've seen multiple really promising engineers get a hold of AI tools, and just outsource all of their thinking to it.
The self-infantalization is so bad that I was pair programming with a guy one day (partly to see how he was using AI) and watched him ask Claude if it makes sense to do X for every single decision.
I get using it as a form of linting... But you'll never learn how to be an independent developer if you constantly outsource your decision making. And it's disappointing too, because he was developing so rapidly as an engineer before Copilot came out.
This is a fantastic way of working with agents in my experience. It's like have a peer architect who can challenge you and help you improve. You're projecting your own feelings and fears by calling it infantalizing.
Sorry mate, but if that isn't outsourcing one's thinking then we live in different realities.
I feel like this is a bit of cope.
Right now you still need to have some skill to guide these things correctly to produce cohesive and functional products, but at the rate we've seen them improve I question how long this will remain true.
Before AI, most big software was desgined and originally writen by a few key (founder-esq) architects. But they can only add functionality at human speed, so the team grows, and the quality of engineer drops as the functionality footprint grows. Eventually the functionality is much bigger, but most of it was written by a much lower quality engineer, and thus the code (even if functionally correct) is less efficient and less clean, and the big refactors a talented architect would have done never happened, so it just got bigger and bigger and more unweildy and bug prone and inflexible - until some new talented architects see the waste and build a startup to displace it.
With AI, big software can be entirely written by 1-3 people, plus alot of agent usage. Which means it can be refactored more, and the design kept cleaner. But this only happens if those senior architects are actually paying attention and controlling the design. If the agents are heavily automated and subtasaking and controlling the design, then nothing much changed, because the agents themselves are no better than the "stackoverflow engineer".
Personally speaking (and I'd love to hear others' takes on this): when using an LLM for work-related and development tasks, I never use the "full-auto" mode, and I never manually approve of something that I don't understand. When I don't understand something an agent wants to do, I go on a side-quest to learn more about said thing and to educate myself first. This takes extra time, but I feel that it's the right thing to do, so I can at least approve/deny/redirect from a more informed position, rather than flying blind and hoping for the best.
In addition to what the author discusses, I think skill-atrophy, stagnation due to complacency (i.e.: "why grow and learn if an agent can do it" mindset), and cognitive laziness are additional risks that come with overrelying on LLMs. Humans were meant to think. LLMs are a tool.
I know it's a cliche but the old IBM adage holds very true today
Machines should work, people should think
Maybe that's part of the problem I have with LLMs writing code. It would be nice if they just did the work, but there's a lot of underlying thinking and decision making with software work that is being offloaded any time you have the LLM do it
It seems like those decisions are being handwaved off as "not important" nowadays. Just let the LLM make those choices! But that is not sitting right with me for whatever reason. Something I should think about I guess
This is the challenge of the middle class developer. They aren't accustomed to working with constraint thinking and they're past the junior stage where one is expected to still be shaping their thinking so they are struggling to find a fit.
That's one way to frame it I guess
I would frame it as "they have been abused by AGILE and impatient PMs into never actually taking time to do constraint based thinking or design"
It is impossible to think about constraints, or really do any proper engineering, if you are constantly "sprinting"
Edit: I also don't personally like engineering based on constraints. It feels like constructing a building based on where walls aren't allowed to go. I get that defining constraints and letting the software go is where a lot of useful emergent behavior lives, but I struggle a lot to think that way. Maybe I'm not wired right for software in the end
That's ironic given that some of the Agile Manifesto signatories are some of the biggest proponents of constraint-based development. While the Principles behind the Agile Manifesto is not prescriptive, I am not certain you could, in practice, even satisfy many of the principles without constraint-based development.
> I also don't personally like engineering based on constraints. It feels like constructing a building based on where walls aren't allowed to go.
Engineering is all about constraints. That you then shift to talking about constructing a building is curious as it would be atypical for an engineer to work on constructing a building. The engineer's role in building constriction is typically only in defining the constraints. Construction crews, made up of an entirely different group of people, then construct the building within the constraints set. "Constructing a building based on where walls aren't allowed to go" is essentially how buildings are usually constructed. It is an interesting parallel as the LLM is somewhat like the construction crew, which is something software hasn't really had before in any kind of big way.
Engineer gets thrown around pretty loosely in the world of software, but elsewhere, especially in places where failure can cause serious harm, someone who constructs a building by applying judgment, experience, and craftsmanship as they go would be considered an artisan, craftsman, or something to that effect rather than an engineer. That seems closer to the world you like to live in. There is nothing wrong with being a craftsman, of course, but the economic fit is becoming less clear as the industry matures. Which is something that seems par for the course. The early days of building construction was also dominated by craftsmen but as it matured engineers became dominant.
Yes absolutely. I don't call myself an engineer, I'm a developer. Software Engineer is a title that my jobs give me, but I'm rarely given the time or resources to do any engineering.
It has become very clear to me over the years that I would much rather be an artisan than an engineer though.
Are you sure it is that you are not given the time rather than your artisan ways consumes your time 'unnecessary'?
Failure in (most) software isn't going to harm anyone, so there isn't much technical need for engineering in software. As I am sure you can attest, artisans are fully capable of delivering great software. Some of the best software out there was created by artisans!
The software industry is headed towards engineering anyway because engineers can build software faster, which is considered a virtue in business. That was true even before LLMs, but has become especially pronounced in this next era.
> It has become very clear to me over the years that I would much rather be an artisan than an engineer though.
Understandable. I suspect a lot of engineers would rather be artisans—not just in software but in general. Artisans get to run at the forefront of new technologies and ideas before rigour is able to be established so it is, on balance, naturally more exciting.
I'm not certain of much these days, but I'm pretty sure of this.
Any time I have tried to properly "engineer" something with documentation and specs and planning I've been told to just deliver it instead
However, it seems like both you and your employer both want artisans anyway, so it sounds like you have found a good fit. The software industry is putting more and more emphasis on engineers, but that is far from being universal yet (and will likely never be 100%).
with critical thought*
fixed that for you, only sith's (and unreasonable people) deal in absolutes; you almost did!
This is a sentence that if written just 5 years ago would result in you being seen as crazy. "LLM capable of any sort of critical thinking? Haha. Not in 50 years."
It never ceases to amaze me how people are stuck in the here in the now and just accept the new reality as if it had always been this way, and will continue being this way in the foreseeable future.
This is the worst LLMs will ever be. Not outsourcing critical thinking to LLM will be seen as a liability in the not so distant future. Just a year or two ago almost no one even took LLM seriously for coding. Now the status quo has moved for also critical thinking, and we hear comments like this. LLM's chances of making a mistake will be orders of magnitude lowers than humans. Slowly learn to let the wheel go. AI will be much better at holding and controlling it.
"We should NEVER outsource number crunching to calculators. They are not 100% reliable and we can make mistakes when inputting the data." Someone in 1920's probably. I know it's a metaphor, and like all metaphors can't be compared 1-1. But it's to make a point how it illustrates my argument above.
If that's true, you're fucked. Because then what good are you for? How long do you think they'll pay you to be useless meat-in-the-middle?
Not outsourcing your critical thinking means trying to preserve a scrap of value-add for having you around.
> "We should NEVER outsource number crunching to calculators. They are not 100% reliable and we can make mistakes when inputting the data." Someone in 1920's probably. I know it's a metaphor, and like all metaphors can't be compared 1-1. But it's to make a point how it illustrates my argument above.
That's a dumb analogy. Automating one activity cannot be extrapolated justify automating all the activities, including some of the most human ones.
The fact that you’re nervous means you will be the first to be replaced!
Is that sarcasm? Cause it's not too different from something I'd say sarcastically (e.g. it's very 10X AI engineer, very overconfident while missing pretty obvious things).
I'm not AI maximalist. But with how things have progressed the past 4-5 years, I'm more confident on the above being true, than not.
I don't think intellectual work will drop off overnight. There will be a long period, perhaps decade or two, where many jobs will just gradually disappear, where salaries will be suppressed, and humans will just become AI-babysitters and auditors.
It is a uncomfortable scenario, but people - especially young ones about the enroll college or early in their career - should consider the possibility as realistic.
What I'm sick of is this passive acceptance of technological determinism. Why build a technology that's so corrosive and so destructive to so many? You've got powerful people talking about creating a permanent underclass, and happily charging forward anyway. AI is literally the most anti-human thing ever, and should be opposed politically.
But there's been so much indoctrination it will be very difficult. For instance, software engineers were so fucking smug for decades, foolishly adopting libertarian ideas while imagining themselves to be capitalists. We resisted any efforts towards unionization to create translate our (former) economic power into political power. Now we're literally the first on the chopping block.
The real danger is not that AI becomes smarter. The real danger is that humans never learned how to justify their existence except through labor.
A less laborious future is called mass unemployment. We have none of the sociological or ideological infrastructure to make that anything but a dystopia, and are making no progress on that front. Just look at what happened to the rust belt, what reason do you have to think things will be different this time?
If a happy, abundant communist future was in the cards, we'd have had it decades ago. The limit was never technological.
"Universal basic income" is just a sop to mute resistance to buy time while a small few grab most if not all economic power.
Will we eventually be so accustomed to LLM's that we will be similarly shocked when someone elects to not use them?
I don't agree with _never_ outsourcing decisions to an LLM, but the parent is right to point out the importance of thinking critically instead of blindly trusting LLMs. If only to understand their biases and common failure modes. The 1920s calculator metaphor is apt because practitioners using plugboards and Hollerith machines would have been avid early adopters but still keenly aware of the limitations of the device. They used that knowledge to decompose problems into units the device could solve, and to sanity-check the outputs of problems based on their understanding of mathematics and the capabilities of the machines.
I am often amazed at the dismissiveness of AI skeptics given the remarkable results we have seen in the last few years. And the stunning inefficiency of major LLM models and inaccessibility of underlying data mean there are a lot more gains to be had. But despite that, I'm even more flabbergasted by those who claim that AI superintelligence is a thing, that LLMs of all things will outcompete humans on creative and critical thinking tasks. It's a naive extrapolation at best and is completely unsupported by any coherent model of technological evolution, economics, game theory, or human history.
But all that said, I'm of course biased. I am of the belief that humans can do things that machines will never be able to no matter how advanced they become. A quasi-religious belief? Perhaps. But AI boosterism just as indefensible.
Of course, this is economically efficient. Nobody is going to give up Amazon same-day-delivery so that some local small business owner's kids can live better than the median person.
I always heard it as "petty" bourgeoisie and was a bit confused. Now I get it.
If the bad scenario happens and 99% of the people becomes irrelevant to the economy, everybody will live their life's worried about basic necessities and smart hardworking people will be richer because your background or where you live or grew up doesn't matter.
Life is not fair. We should accept that AI companies and billionaires deserve to be aristocrats. They worked hard to create these conditions. In the end, it will trickle-down (this one I partly agree, irony aside)
I don't believe this at all. Social mobility definitely existed. It was at least possible to educate oneself and rise in society. Maybe the effort required wasn't equal for everybody, but it sure as hell wasn't impossible, because I've personally seen it happen.
That is fundamentally different from this supposedly K shaped economy world where it is literally impossible to rise. Education and talent don't matter anymore. It looks like the possible futures are either a post scarcity society or a cyberpunk dystopia.
If you believe that, nothing will change much. It will still be possible, just the effort and luck required will be way bigger for the middle class to become rich. That's sad, but life is not fair and we are not entitled to social mobility the same way we are not entitled to housing, food and leisure.
If the cyberpunk dystopia happens, the trillionaires will live in the moon or Mars, and we will live here, maybe with shittier lifes, but that's on us. If we want to avoid that, we just need to become billionaires as well. Sadly, I'm too lazy for that, so I accept that it will never happen to me. I accepted that I will be "permanent underclass", because I don't see a reason for post scarcity to happen.
> The petite bourgeoise sink[s] gradually into the proletariat, partly because their diminutive capital does not suffice for the scale on which Modern Industry is carried on, and is swamped in the competition with the large capitalists, partly because their specialized skill is rendered worthless by new methods of production.
Which means our pipeline to senior engineer is completely broken.
Wages are certainly going down for most software roles
There is a budget and when it is gone, no contractors until next budget round.
There are only so much customers to chose from and all of them have finite budgets.
The exponential growth curve only exists in MBA books.
You can see current AI hype as example, and its government didn't step in and printed N trillions yet.
If maintenance and security is fully automated and for small changes or a small feature you will only dump some spec document into your agent platform, for sure.
If you're in a product company and your development backlog is empty, run. That company is about to go out of business.
I have stupid question here. Why they sell tokens instead of AI generated full application and AI fixes to your code without you needing a single dev?
Naturally we can't use figures of speech.
And now your comparison is inaccurate. I said whole application. So the correct one would be selling/renting construction vehicles vs building entire building and here selling/renting is maybe 10% of developer income.
Digging a hole is like making small code change and if you wish to continue using this analogy then tokens are digging a hole and selling entire applications (thing Software house do) is construction company building entire building
Second obviously deliver more cash and here AI premise starts to crack. AI can't deliver anything good, costs much more than developing team (Uber proved it) and even if you use it as hard as possible and it does what it suppose to deliver max 5% increase across the board
But the current state of AI is a very good indicator were it is going. Even if we don't achieve AGI, do you think AI in its current form will not be better in 5 or 10 years and we will have this solved a lot more/better than today?
Even with AI, you still need to design the software, test it, try it out, deploy it and scale it. An proper agentic platform still needs time to be build.
And the models need to be a little bit better and for that you want human feedback/reinforcement learning
This alone will lead to being able to run a fable class claude model 24/7 and potentially running something like this in parallel multiply times over.
In my sector? No, not really. Because the core problem isn't tech, but labor rights. Those will only worsen.
You are comparing what it is with what should be.
There was a submission a while back that might be relevant here: "Why Law Is Law-Shaped" (lawvm.org) [0]
PDF space is still more advanced than the people typing into "word processors" however. Making software to emulate letters was such a massive mistake for the trajectory of computing, it let people effortlessly "adopt computers" by making a digital facsimile of their terrible analog processes. Only with AI we now have the ability to digest all this unstructured mess.
A lot of AI believers (me too fwiw) seem to forget it’s a lot harder to ‘close the loop’ on non-code projects. I think this is because they are usually coders.
Which is kinda proof they're populated by sociopaths with extremely little empathy. The people who are building that stuff are programmers, and if they had a tiny bit of functioning empathy they'd stop or slow down or at least be unenthusiastic.
And we're not talking about very high level empathy here, but the very basic kind of thinking about the effects on someone very much like yourself.
Not necessarily, there's a growing and somewhat untapped market for BBWs
We keep hearing this, but where is the Photoshop killer written by a gas station attendant? Where is the PayPal alternative written by a retired nurse?
Over and over we're told that software is now trivial to write, and Claude is evidently writing some billions of lines of code a day, but where are the results? Where is the vibe coded app toppling the legacy hand-coded monster product from 20 years ago?
There are definitely more apps developed these days but I haven't seen anything much vibe coded which actually seems to have staying power. Everything is prototype quality.
photoshop, paypal, and many more companies etc. have software of vast complexity that cannot be reproduced or maintained today solely with llms, ipso facto you still need software developers or some similar role to build and maintain the complexity of _yesterday_
some guy shipping an iOS app to zero users doesn't change that. although i think it is good we can have more bespoke software.
We get about 10% YoY now, which is actually impressive, but not even close to the past experiences. Computing power used to take 18 months to double, and was being attacked at a bunch of different angles.
Now we are literally out of tricks, to the point where we had to undo some of those tricks because they were fundamentally flawed, and it takes 100x the engineering investment to get that 10% YoY, or sometimes only every other year, and that isn't going to continue for much longer.
We can't increase clock speed much. We can't increase density much. We are out of clever tricks. It takes an entire earth's worth of human talent just to produce the machine that produces the chips. How the hell are people still insisting that computing power continues to follow Moore's Law?
Several of the limits we've hit are fundamental matters of physics.
Meanwhile, LLMs ask for orders of magnitude more compute than is cheap and cheerful right now. Do we even have a single order of magnitude left for compute?
This is in a way the same argument that all companies will use just boxed (albeit customized) software. In reality many, ie banks run their own custom software and for good reasons. Wake me up (in retirement) when any major bank decides to run their finances, regulatory stuff and transactions on llm-generated stuff made by underpaid devs like you describe.
We're doing a great job of that right now, aren't we?
LLMs are non-deterministic so any interaction with them is a bug inducing act by definition because you don't know what you're gonna get.
What can a mid level person do? Instead of a consultancy loaning out a team of 3-4 people, it might just be one person now. That could mean a lot of downsizing.
One thing mid level people wouldn't be counted on to do was create Photoshop or Paypal. The original thread is about top level pros being the ones who stay in the industry, right? That sounds about right if we're moving the conversation over to Photoshop and Paypal.
- if it is true that AI enhances our abilities it just means the goal posts move of what was expected for each level
- the complexity ceiling will rise for the level a superstar or a company is capable of maintaining, meaning there will still be stratified complexities for the mid levels of old to handle, it might just be higher than before
- counter intuitively but time and again increased software creation more often than not increases demand for more software rather than decreases
if the world decides it has no more problems to solve with software, then we are in trouble. i don't think that is happening anytime soon.
If its so good why aren't you rich?
Seems like so far the market is not convinced at all that SaaS companies as a whole are any more disruptable than before.
Most people book flights online, travel agents still make a lot of money. Doesn't negate that travel agency as a business is economically worse than ever.
Most people have cameras in their pockets that can take good photos, photographers still make a lot of money. Doesn't negate that being a photographer is economically worse than ever.
Hopefully, you see the pattern. You don't remember that companies that are no longer around.
Bun gets a lot of hate for vibe coding.
I vibe coded to modernize one of my old hobby websites (so not even vibe coding from scratch) and I immediately got anti-AI comments, and I didn't even say I used AI.
Well that's where we're seemingly at an impasse, no?
I don't even like the term "good vibecoding". The term was implied as a means to just let the computer type its own code and "go with the vibes". i.e. you have no deeper idea on how it works underneath.
Now, AI-assisted coding? It can be good. It can be a rush job. But the idea is that LLM's are in the passenger's seat, not the diver's. Much smaller chance where you have no idea where you're going since you're at the wheel.
There was not 1 mention about anything being broken, they were simply complaining about AI.
Anti-AI psychosis is a very real thing that is happening https://x.com/Jediwolf/status/2054776716770320631
Ai did that with whatever cli tools were available and what it would write itself.
Ai is not a faster horse. It is a phase shift.
We won't see a gas station clerk write photoshop because we won't need a photoshop.
100% agree. People are looking at the future through the lenses of the current paradigm just like when people from the past imagined the future (our present) in a way which we now find hilarious. Most of the time, the future doesn't bring developments which improve an action in a scalar way (faster, shorter, stronger, etc) but instead fundamentally change the nature of that action (handwritten letter communication vs video calls) or completely override the need for it (telephone boxes vs mobile phones).
But if I can clarify my point. It's more that I'm trying to say "Company promises A is happening and B is the necessary consequences to achieve it".
I do not believe A is happening but B is occurring despite that, in order to achieve hidden agenda C. Though in this case, C is not that hidden since every other article has them blabbing out loud about "wow it's going to be so amazing when C happens!"
here,
A = AI is making us more productive than ever
B = This will cause impacts on jobs and the economy as a whole as we realign what labor is
C = Companies make more money than ever as it works towards eliminating labor on massive (90+%) levels in order to maximize profits and moating the idea of knowledge itself
We are all scrambling to figure out what else we need to do (and so are many other roles).
En masse, I argue not. More productivity for engineers would not be met with mass layoffs if engineering production was why value was being added. On the contrary, other industries have had to hire back talent becsuse companies were too aggressive cutting people and needed that work to be done.
But I'm not an oracle. I can only speak for what I see today and won't predict tomorrow. Especially in these trying times.
Everything else is something else you care about, but producitivty is simply proven for almost every engineer on the above point.
You're not getting my point, and it's not hard. I disagree with this statement.
>producitivty is simply proven for almost every engineer on the above point.
I've read otherwise.
Even if people could find the tools, they won't seek it if a one button solution can come to them. But we can't outcompete Instagram in a prompt, nor some popular app.
Agentic solutions just don't have these issues. You give them your image, that's it.
Yeah, that's the marketing pitch. Much easier to fall into that than really think and approach how you perform a task.
A photo with adjusted cropping, background blurring, and contrast etc?
I'm a doctor and I'm building my own EMR system.
I've also been a hobbyist programmer for over a decade, but the point still stands because without LLMs I wouldn't have the time to even try it.
Sadly, we have trained software users to pay for shit code.
we are entering the world of smaller service firms (1 - 3 people) - where technical chops will even get paid more. the age of cookie-cutter apps is over.
Whether that is due to AI or other economic conditions is an exercise left to the reader.
I mean, think about it; just a few short years ago there was a very strong market for software engineers, despite outsourcing and immigration being very much part of the landscape.
I mean, I wrote this 12 years ago in response to similar discussions on this same site, and in the intervening years, we had a great market for software engineers: https://journal.dedasys.com/2014/12/29/people-places-and-job...
What has changed is 1) the zero interest rate environment went away and 2) LLM's.
I was very fortunate to get a job in a NOC a little bit after high school where I learned things one'd expect to learn in an entry level job. The team I worked on was all about mentorship, learning, and building people to the next level.
Haven't seen that attitude elsewhere in my entire career except in the non-profit world where I reside these days. It blows me away that people are surprised that these industries have failed to build entry level positions.
Which of those things changed (along with higher interest rates) in the past few years though? All the other variables did not change. They were present 5 years ago and present 10 years ago too. To me that's indicative that those factors are not the cause of a soft market for software engineers in 2026.
I am talking about the weak market for software engineers right now and what caused it.
The front fell off because the base was never built to support a shakeup of the industry. There's so little support, now and for as long as I can remember, for people to fail gracefully in the field. It's just up up up. And now that programmers are finding their jobs to be a little more precarious, maybe folk will start supporting mentorship as a practice.
This isn't just a "market" problem. It's a problem of people not teaching others skills that help them thrive inside AND outside of work.
A lot changed very fast in the last few years. It's not all nor even a major part due to outsourcing/immigration. It's a myriad of factors all colliding at the same time.
There are around 100k U.S CS graduates . You're telling me 100k H1-Bs don't make any impact on them?
There's also only 60,000 H1-Bs a year for private companies.
Lastly the majority of H1-Bs doesn't go to software engineering jobs, it's around 30-50%.
There's also basically no US company hiring juniors via H1-Bs, so yeah, I'm saying it doesn't make any meaningful impact.
30K H1-Bs versus 400K grads...
Actually, more like over 80,000. They have a separate pool for people with advanced degrees (MS or higher) in tech fields.
Agree with everything else.
On top of all that the commonplace practices of ethnic nepotism and hiring kickbacks.
I think many engineers are extremely naive about what is going on in the industry, which is why these abuses only continue to increase.
But despite me saying that, I think it's going to take longer than four years. It takes a while for people to realize that a dream is dead.
Now with agents, you can get really bad (vibe coded) code bases in a week.
Before, to get this kind of experience, you had to work in a company for at least 2 or 3 years.
I agree with most of this except this. Think there’s some rose tinted glasses here or I’ve got bad luck over time.
Life before ai was bad as well. There wasn’t any one to explain to you anything! You had to figure it out yourself. The people either already left or was busy with something else.
No one wrote tests (to my standard). Most of the ops works was skipped. Docs were just not there. Nobody linted properly. Just bad mannnn
the vpn is called dev-test-prod and some containers are stored in a dev subscription, but still used in production. Some intangible network error forces you to use the production cluster for testing (the bucket is at least called test).
I feel this kind of setup is invariant everywhere I go to do engineering. Fable level intelligence has no effect!
>There used to be a time when people sat down and talked about how they'd do something. Now they can just prompt an agent for a few hours and open a PR.
>The most tragic aspect of this way of working is that, to the untrained eye, it works.
>If you pull the branch and test it, you'll probably get something somewhat functional. So what do they do? They keep going. Again and again. Until the project reaches a point where no one knows how anything works.
Isn't this the opposite of failing faster, it lets people who would have never made it past the first few hurdles and give up get deep in and then the false hope that they can then prompt their way out of whatever mess resulting in deeper and deeper spaghetti.
The thing is I've worked on plenty of code like this written by humans. AI just accelerates the process and puts this type of code within reach of more people. It could be seen as a step backwards in good software engineering practices we've painfully learned over the last two decades. I see it as a cycle repeating itself in a new iteration, with the hope that we'll end up with still better tools and processes in another few years. But I agree it can and will result in real harm in the meantime.
Bruh..I haven't consistently sat at my computer for even a hour at a time to code for a decade..people spend that much time in Claude??
There are still machinists doing things by hand, but for real production or prototyping, most will now use a 5-axis CNC machine. It still requires an operator of sorts, but much of the work that once required skilled manual machining is now done by CNC.
I think the same thing is happening here; it’s just that the transition is messy.
Give it five years, and how we get to the end result will not matter nearly as much as it does now. A messy codebase will be irrelevant, as it will be something managed and controlled by the LLM, written in a way optimised for itself, not for you or I.
At that point we might as well invent an LLM-optimized language to use.
Sure, just wait for the poors to stop rebelling. It will all be over soon.
I think perhaps the equivalent would be “this environment quite literally can’t support having an LLM attached to it”, as in say some totally airgapped AND low-performance things (industrial computing, PLCs, military stuff, etc.).
Indeed the fix did work, but when I asked him to explain me the problem and the fix he started to use the prompt to get answers.
At that point I just let it go, the only thing that I mentioned later on is that I'm ok with pushing that to prod if that was ordered to me but I'm not responsible for it.
I prefer to keep the bug live until I fully understand the problem, reproduce it, come up with a solution and maybe just maybe perform a check against what a computer generated.
Please note that the bug came from a real human code base but being complex and not familiar with that part of the code (moreover the code was handed to us without any type of support/documentation) rendered me in a weak position where I couldn't come up with a solution so far.
How can someone trust so much a computer generated hotfix without fully understanding a problem is what still baffles me.
Still resisting to use any aided coding, no LLM is not going to steal the capacity to use my brain. The day I'm forced to used these tools, the day I quit.
If "can you explain this?" is a question a direct report has to put into a prompt, they are failing at their job.
This is especially impacting Indian tech workers in the US [0] since these are often the types of roles that InfoSys and other foreign tech consulting firms are staffing. The new $100,000 fee to sponsor an H1B visa has made it difficult to justify hiring foreign tech workers when most of the time they are just going to be using American LLMs to do their work anyway.
[0] https://thefederal.com/category/news/h1b-visa-indian-tech-wo...
"""A Roman idiosyncrasy about counting reinforced this avoidance. The 360 degrees of longitude, for example, were always measured from the vernal equinox, which lies in the zodiacal sign of Aries. This should be zero degrees, 0°. It was common, however, to call it instead 'the first degree', Aries 1°, as Pliny did around 60 AD, upsetting his calculations and those of many who followed him. It amounts to this: if you lay out four marks on the ground and step from the first to the last, have you taken three paces or four? Clearly three; yet four marks were involved. To get the right answer it helps to call the starting-line 'zero'; then the number at the mark you step on will correspond to the number of your steps. But the Romans counted so that three days after Sunday was Tuesday; the Italian for the fifteenth century is the quattrocento — and all of us still call the two steps in music from C to E a major third, taking the number from the three tones involved."""
I wouldn't say that the set that has one element, labeled 0, _has_ zero elements; it has one element with the label 0. Right?
Although, I don’t think immigration or country of origin is particularly relevant here. I never worked in the US but there are plenty of "assembly line" developers here in London too.
If your job is essentially taking a ticket and turning it into code without contributing much else, then yes, I think that category of developer is going to be decimated.
That applies equally to everyone.
You get a task, how does it interact with all other invariants? What are the implications on data flow, processing and user workflows? You can rarely answer those questions beforehand, you step on them during programming as the formal language forces you to take them into account sooner or later.
If you outsource this knowledge-building you’re losing the steering ability when stuff hits the fan. You lose the ability to navigate the code properly in order to identify bug or violations of invariants.
LLM optimize locally, that’s their nature. Invariants are often implicitly scattered around the whole code base. Explaining them to the LLM is much more tedious than just to write the code in the first place. At least for me as I have much better expression-ability in Code than in natural language when it comes to describing any form of computation.
Darwinism in action.
I don't believe A.I. will change much, but it will lead to winners and losers, that's certain. Lessons will be learned, A.I. will remain but play a minor role, just like IntelliSense and ReSharper.
People need to understand that when things break management will hold you accountable, not the A.I. If you can't fix it you'll be out of a job. So you'd better make sure that you understand the generated code and clean it up before putting it in production because you'll be maintaining it.
>The person adding Kafka should have been able to explain exactly why it was needed.
Here it is. People who don't know what they are doing are adding infrastructure layers they don't understand, can't envisage operationally in the future, and missing scalability. I'm seeing this. In fact I'm spending hours a week fighting it. I had to set up a call with a senior developer recently to explain why his prescriptive attempt to make infrastructure changes in his project can't be done with Claude like he did it.
It's playing wack-a-mole as the "velocity" has gone up of changes, and it's promulgated by every manner of product manager and senior developer under an attempt to please the brass.
>The person who built the feature should have been able to explain where the data came from without sending a link to a Claude conversation.
And they won't - because it's too embarrassing when you see what Claude responded with and someone failed to question.
We're in a new era, that's for sure.
Bad news: by delegating the thinking to somebody else (Claude) you have become the management.
I'm not working at massive scale. I've not built any public-facing projects from scratch. But I have done years-worth of cleanup and improvement on projects that I'm very familiar with and have been in my backlog. It's not 100% success, but it's better than I could have done on my own, in the last few months anyway.
I'm at the "this takes the scut work off my plate but damn if it doesn't also take the fun stuff off my plate too, and might put me out of job before I'm ready to retire in 8 years" point.
Though I've done the corporate America thing long enough to appreciate that 8 years isn't really all that long, maybe there's hope.
You are still an engineer but you’ve delegated your technical judgement to an LLM. You just stopped doing the most important part of your engineering job.
Every layoff just automatically attributed to AI even though they have nothing to do with it
I believe wholeheartedly that things like Claude code bring immense value but to management types they aren’t visible enough to prove their “ai first” narratives resulting in a bunch of crap they have us build that look and seem smart but in fact are just slop we have to deal with the consequences of. Good for job security I guess, but I’m getting pretty tired of it all.
Conversely, the product guys I work with are adept at producing proof-of-concept tools that look really good. Fake data, runs entirely in a browser, but conveys their goals way more specifically than Balsamiq ever good. And I think this is a great use case for Claude.
But what ain't happening here is product guys producing code that would go directly into production. And even if it could, they're not in a position to provide tech support or debugging when it breaks, so they don't want to be in that position anyway.
Nobody can really predict the future very well, it seems, but my personal best guess is that we end up moving the boundaries of what we work on and how, but the need for humans isn't going to go down. As magic as LLMs look sometimes, I constantly run into reminders of how much it relies on how I phrase a prompt when it delivers any kind of answer. That influence really drives how satisfying the results are.
I decided to start learning programming about 6 years ago as a possible new career path. The universe was not going to have that so AI was created.
LLMs spared my neck of the woods for now but is this really how PR review looks like these days for an average SWE or its just an example of a Junior in a team?
> Fixing it would require such a colossal amount of work that it would be impossible to even start justifying it to anyone in management. > And what are you even thinking about? It would end up in the exact same state again in just a few months anyway.
The management side of this probably deserves a whole post of its own. There’s only so far I can take each tangent before the original post becomes too long for anyone to finish.
This hasn't been my experience. Especially when it comes to enterprise software, eventually everyone that was involved with the design of and iteration on a system will have left the company. Yet, often those systems need to continue running because they support "legacy" customers (who sometimes actually tend to be more economically valuable to the company than the customers on the shiny new system).
Before AI, in these cases you just had to dive into the code and start trying to understand it yourself from zero. Usually, you would come to a very limited understanding of the system, just enough to fix the latest bug or keep it running until it hit another issue.
I'm not sure why it's necessarily worse to rely on an agent to do this for you these days.
What I thought the post would be about is the dissolution of the White Collar Kitchen Brigade The kitchen is run by the Chef but it needs the Sous Chef, Line Cooks, Kitchen Hands to operate.
Many software engineers have made a good living acting as the sous chefs and line cooks underneath the rockstar chefs, but with AI companies are inclined to turn the whole kitchen over to the top dog and their AI crew and the ordinary human crew is slowly being churned out.
Nevermind the aspect that thses sous chefs could one day be rockstars, because no rockstar came straight out of college outperforming their senior's skills decades prior. You're hollowing out whatever isn't profitable at the cost of future talent (and likely the future of the company), but those holding the money don't care. They'll move on the the next company to suck dry.
And it's not just because the agents execute faster than humans, it's primarily that they have lower friction to onboard and off board. In the past we needed a "standing army" (salaried, full time work). Again this is not about the soldiers in the army being bad of incompetent, those are excuses. The real reason is that it takes a lot to train and maintain a soldier. Bu t when we now have ephemeral agents which spin up and down as needed, then there is going to be a strong incentive to cut down on the salaried middle class.
Simultaenously platforms like Mercor which offer white collar task based gig work are on the rise.
The logic is that ordinary humans are becoming too expensive to maintain on a standing basis.
A bad engineer has been lazy for years and will never change.
You likely have experience with this already first hand. Ever had a lazy day and just hit "yes" "continue" on the AI over and over? I've had to revert entire days of work because I was so burnt out I didn't put effort into the design.
A good rule of thumb though is if an AI can't solve the bug and fixing it creates more you have a bad abstraction and architecture that needs a gutting and rebuild from near scratch.
If you can’t answer this basic question then why tf do we even need you around?
Adding AI to the mix just made things worse. I'm still finding issues in the codebase/documentation that I need to review, test and fix.
The replacement is being trained. I made sure that, while I expect them to use LLM supported development .. they own their contribution.
This is going to be a fun ride.
Faced with that situation repeatedly, most people would find it sensible to resign. Which leads me to another point: if you leave, it will likely be difficult to land another job assuming that companies will impose a ridiculous interview process in fear of a bad hire which will be increasingly expensive as the author argues.
I realize that this is nothing new, but if there are fewer middle-class engineering roles, then I expect that these existing problems to become amplified.
https://www.youtube.com/watch?v=axOcn--n_lM
Some feel more productive, and we shouldn't kink-shame peoples cognitive dildo. =3
I recently joked (only slightly) that it's currently possible to get yourself promoted at these orgs using tokens as a productivity proxy by spending your days having Claude OCR dictionary pages.
The concerning corollary of that joke and this management strategy is: when do orgs start offloading reviews to Claude? They're already surveiling a large percentage of peoples' day-to-day and are in a position (or will claim to be) to make a judgement about how those tokens are being used.
But, moreover, the demand your company subscribes. But not your company anymore, because you'll probably be replaced by one engineer (and an AI subscription) who's now trying to do your job and about four or five other jobs.
And this one engineer will become more and more reliant on AI companies, AI companies that'll go for the throat once they've hollowed out all the skills that used to exist in the engineering market.
I think I can agree with most of it while also arguing that I don't think good code has ever had an honest measurement of quality. From an end user perspective, the end product either works or doesn't. Working terribly is the same thing as doesn't work and working well is the same as works.
What AI changes is the actual code part. The actual code lines output by AI is identical to or better than the best programmers. The systems design, architecture, QA, integration into existing legacy systems, to just name a few, is where the strengths and skillset lies.
In order to be a good engineer, you have to be a systems thinker. AI or no AI does not change that. The entire picture has to be taken in to account, and I think this is going to obliterate the vast majority of engineers who cannot or don't want to think about systems. It's no longer about putting on your headphones and outputting code. It's about having to interact with other humans, systems, architectures, organizations, and an API or MCP is not going to help with that.
I truly do feel bad for terrible older aged engineers, and the young new grads. I think it's unfair that a lot of new grads were told that CS was a great career, only for them to start their freshman year before AI, and then graduate when AI coding is in full use at nearly every workplace.
Bad workmanship writes bad code in any language. Typically the "easier" the compiler is to use... the more complex the failure mode. =3
This list of rules applies to most languages: https://en.wikipedia.org/wiki/The_Power_of_10:_Rules_for_Dev...
A bit of history where these rules came from, and why they matter. =3
"Why Fighter Jets Ban 90% of C++ Features" https://www.youtube.com/watch?v=Gv4sDL9Ljww
The basis of the cited 10 rules helped form many standards for reliable code: https://www.stroustrup.com/JSF-AV-rules.pdf
"Reflections on trusting trust" (Ken Thompson, 1984) https://dl.acm.org/doi/10.1145/358198.358210
This would be true if the goal was to get good working code faster. But the actual goal is to get any code faster. So, in reality, it doesn’t matter whether you are a good or a bad engineer. It just amplified how good you are at manipulating the hiring process with your fine tuned resume and how smoothly you can talk your way through.
Everyone starts off as a bad engineer. Just like any other profession, you to make lots of mistakes to learn. But now you're less likely to get wisdom from another human to build up the knowledge and experience you need. And more likely to delegate the hard stuff to Claude so you don't learn from your mistakes.
> My bet is that AI pushes salaries further apart. To be employable, there's a bar you have to clear and that bar is whatever the current best model du jour can do.
Since well, there are a lot of jobs in the tech industry that for all extents can be 'solved' with AI. Like if you're developing themes and plugins for a CMS (like say, WordPress), something like Claude can do a very passable job at that exact type of work.
So, only the more senior developers are even needed in that type of work anymore. And even they only need to review what the LLMs provide and fix issues maybe 10% of the time.
Hence the most basic, most entry level friendly engineering opportunities are likely about to be decimated. If your work involves building simple themes and plugins, managing the website of a small to medium sized business or being contracted to build sites for mum and pop companies, then your job security right now is questionable at best.
Being better/more skilled than AI is basically the bar you need to clear to find meaningful employment in this field now.
It doesn't seem to be happening everywhere, but if you are unfortunate enough to work someplace with a "LinkedIn thought leader" high up on the engineering food chain, there's a really high likelihood that your organization is currently in the throes of an "everyone must be using AI for everything" fever dream.
And boy let me tell you, it is every bit as disastrous as the OP claims. Engineering managers are asking Claude to write up entire initiatives, then they hand off these nebulous AI slop manifestos to the teams where the requirements folks are having Claude shit out tons of superficially plausible Jira tickets. It finally lands on some poor engineer's plate and since these tickets are the technical equivalent of Finnegans Wake, they just end up asking Claude to read all this shit on `ultracode` and draft up a pull request. Which is then peer-reviewed by somebody using Claude.
I wish I were exaggerating.
With TxtAI, I've seen a large uptick in PRs (https://github.com/neuml/txtai/pulls?q=is%3Apr+is%3Aclosed+s...). While the extreme verbosity of Claude messages and commits is very annoying (plus the constant defending itself on why it's a bug), I do think it's a positive that more people are enabled.
It does require reviewing the PRs. Some can be tricky just like a human. For example I did merge this PR (https://github.com/neuml/txtai/pull/1136) and it would have completely broke search. But a human could also do that.
From an open source standpoint, I say the more the better. You just have to be willing to do the work to review and no not just having AI agents to review what the AI agents are submitting. There still needs to be a human in the loop, if you care about quality.
Any apparent short term gain is really a prescription for long term pain.
Ignore what AI fanboys say and instead look at what they do.
https://northeasttimes.com/2026/08/07/oracle-bans-ai-code-fr...
The article also goes on to compare the JDK teams policy to GraalVM, also in Oracle which is more similar to the Linux kernel policy, where AI submissions are allowed, but the human submitter is accountable to them, which is reasonable too.
It's not unreasonable, in my opinion, for the JDK team to limit AI contributions based on their stated priorities, just like how other teams might not require those same restrictions.
These are just some of the bigger guys that are either raising seed funding or already well-established... I can't imagine all the small and obscure teams that are chasing the same thing.
https://www.flexport.com/ https://www.loop.com/ https://bubba.ai/ https://alvys.com/ https://www.roserocket.com https://www.withterminal.com/
A lot of these guys have marketshare already and are weaving AI surgically through the stack, which is how people should be building. These aren't AI wrapper companies... these are companies that are leveraging AI to amplify their existing products.
I am not sure why it's so hard for people to assume the semantical analysis that AI offers can't be leveraged properly inside of a product.
Take this one post, and then extrapolate similar products across all verticals... that is currently the waters that are being tested. Law, healthcare, construction, etc - there all getting pressure tested for similar AI integrations.
I don’t have any issue with intentional debt when you understand the trade-off and have a clear payoff plan.
Yes.
Whether any gain is worth the pain is left as an exercise for the user.
And now that code is being watermarked by AI, suddenly they’re artists, painstakingly prompting, crafting, to get just the right code; the watermark is unethical even!
AI psychosis is real, and even some of the smartest people I know how succumbed to it.
In one particular case, a senior teammate of mine went the extra effort to actually explore what the intent of the change is and created a whole new PR for the junior dev that was a simple configuration change of 5 lines instead of the 14k lines they put for review.
This is utterly unsustainable and something will give at some point.
And who is going to want to fix that? Maintainers and systems people were the first to be laid off, by management who never valued the "cost centre" they represented, and the few remaining are trying to fight gravity and will likely take the blame when the systems they oversee fall in a heap.
Any new hire knows they will spend a few years building a mental map of institutional knowledge, only to be tossed on the scrapheap as soon as the system is working again.
If companies want to develop internal software as they appear to, they need to stop defining business processes in code, and certainly stop defining them in Jira tickets. Middle management has outsourced so much of their work to the software or operations departments and now its about to backfire.
I think it's largely correct that hiring bad engineers is dangerous to the company. But that's always been true, especially those "hack out a prototype, get director applause, and leave it for somebody else to own" people. But management has usually chosen to keep such people around, because they can look good on paper (see how many tickets they closed?).
The question is really a management / business-owner question -- will managers/directors stop hiring yolo-engineers? Will they empower engineers to close PRs simply on complexity/size grounds? Will they fund refactors and simplifications as first-class concern? If not, it will be a problem, and I don't envy the engineers who try to be the glue at such a company.
Even if that were feasible in a sustainable way (i.e. LLM-generated code wouldn't drown your code base in technical debt over the mid- to long term), the asymptotic end state of this is that the LLM provider owns the means of your production, not you anymore. How can anyone in their right mind run into this obvious trap?
> By the time you've untangled one bad decision, five more have been merged.
And then there's that. What's the value of all this "speed" when it destroys the most valuable thing you have?
> At some point, someone still has to know what is going on. And that's the most valuable person on the team.
The best you can do is see that you keep being one of those.
One of the problems with the "middle class" in the past was that there were lots of mid-level jobs in big companies but people hit a ceiling and couldn't progress. Maybe the middle hollowing out will lead to more jobs with significant opportunity and responsibility rather than ones where you get trapped because you weren't at the company early enough or all the top jobs are filled.
Now the competent developer can just run agents and do the same review process, except it's ~free (relative to human salaries, even outsourced).
So we've got a bimodal distribution going on where the bottom X% of developers have become essentially worthless while the top Y% of developers are now more valuable than ever.
Even ignoring the shift to token based costs, the opportunity costs of throwing everything onto your "competent developers" isn't free. They still need time to review and correct output on top of whatever else they were doing in their day to day. And they probably aren't getting a pay raise either, so how long until they use that bullet point to jump jobs?
Maybe it wasn't clear in my comment, but this was already happening in many large organizations pre-AI: you had a small contingent of competent senior developers whose job was to review and correct outputs from junior and/or outsourced staff. From people I've spoken to in these types of situations, they're very happy with getting rid of their offshore teams and using AI instead.
I've read different testimony.
So. AI Makes good engineers better, more productive and able to deliver well designed systems.
But it makes the bad engineers 10x worse. Before, they had negative productivity in a team environment. Now, its 10x negative productivity. The mess they create as one person might need 10 people (and their AI's) to clean up.
I would also put people who don't know how to code in that bad engineer basket. They would be delivering code they don't understand, accepting unnecessary complexity etc just like your standard bad engineer.
somehow elite humans are the only ones who can ever reduce complexity?
the tooling is in its infancy. this is the worst it will ever be.
I understand that AI writes better code than people like me in many cases. But an industry should still provide opportunities for those people. And sometimes those people create things that are better than AI in certain areas. The problem is when even those opportunities are taken away.
The perspectives of market advocates often stop at this short sighted level. In reality, their modeling is incredibly simplistic. I will not elaborate at length on their poor modeling here. The short sighted local optimization that only chases the margin of the next quarter is the exact enemy we must guard against the most. (Of course, given the nature of HN, this specific part of the comment will likely be attacked.)
It is not a matter of companies not owing anything; rather, companies are actively committing self sabotage.
Is it truly right to eat tomorrow's seed corn today?
The essence of the software industry is not the 'generation' of code, but the 'maintenance' of it throughout its life cycle. Why is Linux continually maintained, and why is Windows continually maintained? The core of this industry is fundamentally tied to the entire life cycle of a product.
You might be able to fix code with AI. However, under the current LLM structure, can it actually modify projects spanning hundreds of thousands or millions of lines? It cannot. The skill required to partition those architectures is still entirely left to humans. And the ability to define those boundaries is born strictly from experience.
Labeling certain individuals as useless or inadequate inherently destroys the resilience and buffer of the collective as a whole.
Why do humans embrace and care for the vulnerable when society has the capacity to do so? Why do we strive to preserve diversity? It is because, depending on the context, those very traits might prove to be more advantageous. Every human possesses distinct skills, and their unique temperament and proficiency simply manifest depending on the situation they face.
E.g. Buterin, Weyl, Friedman. How we started talking in the first place, remember? It was rather regrettable that we stopped asking each other questions..
In place of that, I'd like to see you, jdw64, try to debate with these high-ranked people (in their own community, anyway) :)
To everyone: How can market reward advantageous situation-dependent temperaments in the long term, is I think my question. That sounds like climate (or weather) manipulation, but somehow I sense both theory and practise are much simpler.
In fact, I think I can even eliminate jdw64's ingredient of "temperament".., framing the issue of conflicting temperanents as one between "generalists" & "specialists". Note that you can (probably) use "Marxist theory" to defeat PP without calling it that.
(I think this is more complex than the debate between "wise" and "clever"?? The gap is itself interesting)
This last one, even all of YC would be interested in, I'd argue. In VC lingo, that'd be "T-shape". see also the thread "Felix & I [& D]". That's either like a person who is like both Jobs and Wozniak, depending on situation, or a Wozniak (/Jony Ive) who has the ability to become Jobs, thus sidestepping the situation-dependence-dependence.
Side-quest one is to redefine both "making a billion dollars" and "writing good prompts" as specialities, so that markets as they are imagined now don't necessarily reward these
Side-quest two is make the chameleon skill teachable (or at the very least into an _identity_ ;)
- you have a very nice article on how llms work here https://blog.florianherrengt.com/how-llms-work.html
- but in your diagram titled "Word vectors plotted in semantic space" dont you think you need to add arrows to show where those vectors are actually pointing?
- because i dont get how you arrived at this Using vector arithmetic, you can calculate: woman + (uncle - man) = aunt without seeing the math vector directions
No confirmation for the title, rubbish arguments and logic.
> Good engineers have become more valuable because AI lets them move much faster.
Bad prediction. This is likely another AI marketing article.
This is the only way I can see it playing out at the moment, because AI has completely eaten away the need for juniors and its also made it hard to train juniors since they just want to yolo it with CC all the time.
So AI isn't really doing anything but giving sharper tools to both groups.
So, as it was before, we simply need to set expectations and remove those who cannot adapt and meet expectations... You know, the way it's always been.
So why is AI the problem here?
This captures the essence of AI generated work Vs your own work. AI generated work just doesn't seem to persist in my memory.
If I design the application model myself then I can play around with it in my head even when I'm not at my desk. I know it inside-out.
If the LLM generated it then I very likely forget it the minute I stepped out of the office.
Sorry to post this publicly, but there does not seem to be any other way to contact you. Your GH page is fairly locked-down, and the link there, is dead.
Your “Hire Me” and LinkedIn links in your blog are kaput (for me). It may have to do with UK LinkedIn not talking properly with US LinkedIn. I can find your profile there, but not through your blog links.
@dang @tomhow I may ask you guys to delete this, if it gets ack'd.
Bonne chance fired senior!
I have depicted you as the 100 line a day weakling, and myself as the 20k+ line chad.
The systems at bigcos are too ruthless to risk gambling your career on this kind of reasoning which you have no recourse to. Best to start small teams and destroy them from the outside.
Nothing else this article says matters much in my opinion. If you're concerned about something, do something about it.
AI is still just a tool.
seems like a petty easy construction, proof engagement kinda thing
- with AI, bad engineers (bad designs?) lead faster to catastrophe - Frontier AI companies pay their SW engineers very much
--> we need highly-skilled sw engineers and the lesser ones will get out.
Kind of what outsourcing did but x100.
As a manager, I'll still have to think how I grow young SW engineers to top SW managers.
IMO The author fails to list the hypothetical person with 13 PRs to review is also failing.
> * The engineer who refuses to change with the times
IMO many of the old ways of software engineering were local maxima. We're still seeking how to hit a new maxima and the journey may take us through zones lower than the previous local maxima.
You still have to understand the change yourself if you’re going to take responsibility for approving it.
That work is fundamentally much slower than generating the code, even with the help of AI.
We’ve made producing a large change extremely cheap and fast. We haven’t found an equivalent shortcut for building a correct mental model of what that change does, how it interacts with the rest of the system and whether the decisions behind it are actually sound.
Maybe one day we'll find one. As of today, I don’t think we have.
There is plenty of software in existence where being incorrect, even once, can spell disaster.
Everything about the picture being painted in the article is anathema to keeping such systems safe and reliable.
Sounds like A.I. in general...
We could end up with a gulf between those who use AI for cognitive inquiry vs passive delegation. Those who accelerate learning by asking "help me understand this" vs those who relinquish understanding and analytical thinking to AI to complete their work.
That's when companies began starting to outsource their work to much cheaper countries
> The new AI economy
I don't know if this phrasing is intentional, but it gives me a chuckle. The dotcom boom was called "the new economy" about 26-28 years ago.
If the limiting factor is the rate at which experienced engineers can understand and validate changes, you have three options: generate less, find a genuinely better way to validate or accept lower quality.
Love this quote. Already seeing so many codebases which became unmaintainable.
We still teach arithmetic and algebra despite computers being vastly better at calculation. We teach spelling, grammar and essay writing. We even teach history and geography while everyone permanently has a device in their pocket that can look up almost any fact in seconds.
How else would you be developing the mental models required to understand, question and verify anything?
I always joke with my wife and invoke a line from this [1] Art Bell episode "the disasters that are coming..."
People really don't seem to consider that our civilization is remarkably fragile and dependent on humans. Any given system can just fail at a moment's notice and you need people around who know how not to panic and what to do.
We seem to be adamant at disproving this reality for some weird reason (money, duh), but life isn't going to be fun when a large portion of the population needs a chat bot to do any form of work. And it's worth asking: what population will be left if we submit all of our faculties to LLMs? My guess is one that's either limited in size or practically inert.
An outright idiocracy doesn't have to happen, but we sure as hell seem to be speed-running our way there. It's actually worth watching Idiocracy and Wall-E and just contemplating "do I really want to live in this world?" Because, at least right now, we're charting course directly toward that.
Software engineering is evolving, and the middle class (and beginner) is going to have to grow instead of being able to leverage the same skills for longer and longer.
It's so true from some of the other posts that you can outsource your thinking, but you should never outsource your learning and understanding.
See "AI Won't Take Your Job, Someone Using AI Will" > There's no lucrative middle ground where 'AI whispering' is a high-value skill.
https://blog.florianherrengt.com/vibe-coder-career-path.html
Nice first name btw
Working on a small, existing, established product that can gradually be improved upon while aided by LLMs if necessary seems like the best place to be. Starting something new (not that I have any legit worthwhile ideas or the resources to pursue them) seems pointless because people are shitting out poorly designed AI slop constantly and poisoning the market.
But what do I do instead? Trades programs are already waitlisted or require another 5-10 yrs to earn something worthwhile. Transitioning to anything else seems like a tenuous prospect. I fear that unless I get incredibly lucky, the last job might have been the last chance to earn a living that made any sense.
To be clear, I'm not giving AI more credit than it's due, and this article describes the reasons for that which are valid, but the perception that they're magic engineer replacers is more important than reality. At least I can hope that the housing market completely crashes or enough crap code is produced by opportunists that I can ride it out, but other than that it's a confusing time.
On the other hand the problem can also be triaged quicker and rewritten faster. Pretty much every startup I joined had at its core disastrous code written by students and overworked techies. I can totally see this shitty base being the future base all startups. It'll likely need an army of agents or devs to make sense of all the spaghetti being written. I won't be surprised if demand for devs skyrockets after the first generation of spaghetti western code "matures".
I mean, it's a huge issue and is still happening. It will be talked about until properly addressed.
You never could.
AI massively increases the speed and scale at which bad engineers can do damage while fixing it is still slow, difficult work.
Are LLMs rewarding experienced developers with tons of productivity gains? Yes.
Are LLMs actively degrading their expertise of understanding code? Also yes.
This article has made the implicit assumption that the top quartile of engineers are immune from skill decline. They're not. If you're an engineer who increasingly outsources the planning, writing, and analysis of code to an LLM, you're losing your ability to plan, write, and analyze code.
All of this is to say--senior engineers who have fully adopted AI tools are blowing smoke up their asses to dodge the reality of their own obsolescence. The senior engineers can talk about productivity all day, but they're only marginally closer to understanding a complex system that was written by LLMs than the "middle class" of engineers are.
You reading this--yes you--get over yourself. Your skills are depreciating too.
Having large teams in the age of AI is pointless. It slows things down and spreads accountability too thin.
When you have one good engineer doing many things, a lot of stuff lives in their head and they know what to look for in their own PRs. Also, people tend to like their own AI slop, but not others. So overall you will have at least an engineer who is satisfied with the codebase vs a lot of people who either have some gripe about something someone else did, or just don’t care at all.
That means you have to put way more trust in a single individual, but if it’s the right individual you propel the organization further ahead than a team of mediocre engineers or senior engineers limited in what they can accomplish.
One possibility is to have firmer APIs for known components. APIs that come with the entry and exit conditions for proof of correctness. That gives an LLM a hard definition it can work to meet.
This isn't as bad as it used to be. We may be able to use LLMs to create entry and exit conditions from specs written for humans and from unit tests. Code is cheaper than it used to be, but so is formalism.
This may be a way to put firewalls around AI slop.
There are a lot of people edging around this concept, but it's not solid yet.
The fact that some teams find themselves there is simply a realization of what I stated - inactive maintainership by not taking code reviews seriously.
But it does cover the case where someone makes it to the top if he/she is junior. Who experience is gained?
Maybe I ask too much from a short article.
That is the "democratization" that AI shills speak of:
https://xcancel.com/dhh/status/2087538364580835804#m
Once a CEO with a snowboard-optimized brain gave you a board seat, there is no way back.
“If it works, don’t fix it” until it doesn’t and we shall see a new wave of software hiring in a year or two.
Every enterprise is talking about AI Transformation, and that great with the right expectations. But those who think AI will just make platforms quick with less people and least experienced engineers, will have to prepare for the deinshitification transformation in a year or two.
Migration plan? Just ask Claude when shit hits the fan. You'll make a plan when you need one.
> By the time you've untangled one bad decision, five more have been merged.
I'm slowly (partially ironically/sardonically/nihilistically) adopting a mindset of accelerationism towards the collapse of software development - it was largely done wrong from day 1 and wasn't "real engineering" to a sufficient degree to not lead to the mess that we've been in maybe for the past 20-40 years. The only thing AI did was take away the brakes and press down on the accelerator, we're already headed towards a cliff and have been for a long time.
If the code in airplanes and spaceships was developed with the same degree of care and attention as "good code", you'd see those dropping out of the sky regularly. If they built bridges like we build software, they'd fall apart regularly as well. Good code CANNOT hinge on the opinions of some senior dev, or even a group of them - it must be provably good. And if it must be provable, then these checks must be automatable. Bad code (whatever that means, however you'd manage to classify the difference between AI slop and what you want to see) should be IMPOSSIBLE to get into the system at all, due to those automated checks.
Be it good enough test coverage, automated checks for usability and end to end coverage of the features, project/domain specific lists of architectural rules (think ArchUnit), needing proofs not just tests etc. We will never have that - our OSes are bad, our browsers and other essential software is bad, our programming languages are bad (the fact that unchecked exceptions even exist in languages is a cardinal sin), same for databases and tbh any other class of software you can look at.
This impassioned comment might border on a rant, but my argument is that the past decades aren't the baseline of good code, we'd probably need to spend 10-100x more effort to produce 100-10x less code, but make the existing code bulletproof - there is no reason for more than one OS to exist, no reason for more than one UI framework to exist (or even all of the egregious ways how the web platform was transformed from documents and links to a collection of badly written apps, which eventually infected the desktop with Electron, due to the native GUI development also being severely neglected), no reason for more than one web framework to exist or even more than one programming language to exist in mainstream usage outside of research and looking for the solution to use for the next decade/century of software development. Yes, I'm exaggerating, but the correct answer is probably closer to 1 than to 1000.
Obviously that'd lead to death by comittee and some degree of experimentation is necessary, so hey we end up with a new slopped together library every week and I know nothing and nothing works anyways. I wonder if we had ONE high level programming language, whether over time it would have evolved from C++ to Rust (sans odd parallelism), and if it was based on formal proofs, then migrating between language features could have also been fully automated, alongside enough pushback to any feature deemed not worth it. On the other hand, even with all of the world's developers concentrating effort, something like that might be above our cognitive abilities, so probably not - just too hard to reason abuot.
We've seen this game before, with the Dot Bomb and 9/11. A lot of you have 6 figure jobs that will simply be gone next year after the election, never to return.
That winter lasted about 5 years until 2007 when the iPhone and social media sites like Facebook went mainstream. This winter won't end. Or more accurately, it is the end.
Maybe we should stop debating whether we're in a crisis and start looking at the 5-10 year endgame of the Singularity. We're entering the eventuality that many of us have predicted since the arrival of the internet 30+ years ago, that prices will get lower but nobody will have any money to buy anything anyway. The feeling that we're doing something wrong with our lives will continue to intensify. We'll try so hard, and get so far, but in the end, it doesn't even matter.
I don't know about the rest of you, but I'm turning my attention away from trying to play the job game with AI. I'm looking instead at how we can provide time/money/resources to the middle class after capitalism can no longer provide them.
A conservative friend of mine just read the Communist Manifesto by Karl Marx, which I didn't see coming, especially since he beat me to it. In the neurodivergent spirit of not being able to do anything alone, what if we all read it?
https://oll.libertyfund.org/pages/marx-manifesto
https://www.marxists.org/archive/marx/works/download/pdf/Man...
I'm predicting that it stops just short of what full automation can provide. Loosely the evolution of economics goes: hunter-gatherer -> agrarian- > feudalist -> capitalist -> socialist -> communist. And now solarpunk (or something).
The working class is looking forward to the next chapter, but the capitalist class is looking backward to neofeudalism.
Those two directions can't coexist, so what does the future hold? Well, it's always darkest before dawn:
"It's easier to imagine the end of the world than the end of capitalism." - Mark Fisher.
https://www.youtube.com/watch?v=aCgkLICTskQ Mark Fisher: The Slow Cancellation of the Future
https://www.scribd.com/document/835022535/Mark-Fisher-The-Sl... (transcript)
https://goodscienceproject.org/articles/the-slow-cancellatio...
https://mediationsjournal.org/articles/end-of-world
If the endgame of capitalism is that it inevitably eats itself, then the game now isn't how to get more money and do nothing with it, but instead how to start doing something with no money.
I should add that even if I'm exploring anti-capitalist futures, that doesn't make me socialist. I don't like the 6 hour daily work requirement of many socialist societies. I think we can do better than that and get closer to 0, so that we can shrug off wage slavery and finally get real work done.
Whether people will buy AI-generated software is a different question. The problem I’m describing already exists inside businesses with paying customers.
I’m talking about established teams working on products that already have users and make money, where AI lets individual engineers introduce changes faster than the rest of the team can properly understand and review them.
Or you simply take for granted the bloodbath the next decade will be before we come to proper talks of this. I don't think that is something to handwave unless you have your billionaire bunker ready.
I don’t think it’s “just a tool”, it’s something that directly compete with the role of humans in a system, by design
Is a very sophisticated computer driven adaptive control system making decisions for the user? Arguably yes. If your car has a bunch of assist tech you are not driving. You are commanding a nonlinear control system.
AI today is quantitatively far beyond these systems but internally it is still just a giant decision table. It’s just a differentiable table that can be automatically programmed by back propagation at what would be unimaginable scale for manual implementation.
As soon as you put a machine between you and the target action that is more complex than what you can hold in your head and that has multiple layers or feedback loops, you are ceding fine grained direct control in favor of a simpler abstract control surface.
I will change my mind a little if I start seeing evidence of genuine volition, but as of now I suspect that’s a property of life not intelligence. One interesting result of AI when viewed as an experiment is: I think it proves that life and intelligence are separate phenomena and that consciousness and intelligence may actually be unrelated.
I have the hypothesis that consciousness (and therefore true volition) is a property of life. You have to be metabolic and tied in some intimate way to thermodynamics and the arrow of time. Solid state electronics doesn’t have this property. It’s unrelated to intelligence. A bacterium may be conscious.
I'm not the parent, but personally, no, I don't believe so.
I always appreciate the "it's like past changes" thought when things change, but in my opinion, this one simply isn't. It's notably different both quantitatively and, critically, qualitatively, than all previous increments in computers/software. This is much more lateral than punch cards -> assembly -> compilers -> frameworks.
Also, regardless of that thought, the "it's like past changes" argument relies on a false implication: That all changes that survive are "good" in the broad sense. Many changes often persist simply because they are inevitable - not because they are good. They have both good and bad parts, and it's subjective as to which side it leans towards.
Though I personally don’t find the topic of consciousness interesting, it’s not something we are able to define and is distracting from all the other aspects of LLMs that should be discussed or evaluated for what they are.
You’re deliberately constraining the output so changes stay small, human-reviewable and reversible. That’s good engineering culture.
It isn’t all or nothing. I use AI heavily but that doesn’t mean I have to pretend there aren’t serious problems with how it’s being used.
So many A car is simply a faster horse arguments being made here.
The “You must review every line of code” camp are going to be in for a seriously bad time when Claude/Grok/etc starts writing machine code, and they absolutely will and you will look like a crazy person the same way as those who said we can’t trust compilers back in the 1970s.
Breaking up code into small reviewable pieces is obsolete advice from legacy software engineering. We will probably be reviewing prompts or functional simulations as a form of review. Which brings me to the point that a Senior engineer in 5 years will look absolutely nothing like a Senior engineer in 2019.
If you don’t understand the system, don’t know what the code is doing and you’re mostly prompting an LLM to make the decisions and implementation for you, what exactly is your contribution?
The ability to operate the tool isn’t much of a moat if everyone else has access to the same tool.
I don’t review assembly produced by a compiler because the compiler isn’t deciding what my system should do. It’s translating a program whose semantics were already specified. More importantly, that translation is deterministic.
A compiler takes a human-specified program and translates it into another representation while preserving its semantics.
If in five years I can give an agent a complete specification and reliably verify the resulting machine code against it, then sure, reviewing code may become obsolete and I’d happily stop doing it.
Also, keeping changes small isn’t just about making individual lines readable. It limits blast radius, makes behaviour easier to reason about, isolates mistakes, makes changes easier to revert and so many other things. None of those properties suddenly become obsolete because code generation got faster.
I ask because I've pushed some of this to the limit in my own testing and when I get the right building blocks / primitives in place in the repo, I'm able to get plans written in a way where I don't just describe what I want but specifically mention outcomes, verifications, constraints, etc. that utlimately describe the shape of my system and my intent.
My plan is my understanding of my system and the changes I'm making, and the execution of that plan (e.g. with subagents), verified against my spec, is the code itself.
With the correct building blocks, I've found that frontier models can write code in fairly predictable ways that lets me maintain my understanding and confidence in pretty large PRs.
I think perhaps the quoted part of your post seems to imply it's not possible / isn't phrased with that nuance?
If you genuinely understand the resulting system, then that's fine. That’s not the behaviour I’m criticising.
If you didn't write any of it? Yes, you only think you know what's going on.
I'm working on this right now, will have a release probably in a week or two. Not machine code but it's essentially a custom assembler/compiler pipeline (close enough) that an LLM can operate via the CLI (you can do it too, it's just way slower) and it emits native asm optimized chunks that can then be inserted back into cpp (working on a rust et al impl). The results are _obscenely_ good. It's outright outperforming gcc vis-a-vis by a MONSTROUS margin, and it's not even close. As in, gcc can do abour 3-4 cyc/byte (arbitrary workloads on a wide variety of tests) and my tool does it in 0.5 cyc/byte if not better. It outright emits kernels that run at a flat 4 IPC for more or less _anything_. You can then have an LLM convert it back into high level C++ intrinsics (not always, gcc doesn't always expose all the levers needed to do so) if you wish. The one downside is that you need to provide fairly accurate cpu arch maps (ie agner fog instruction port/latency tables) for the tool to work right, which is what i'm focusing on right now.