I think almost every new business will have at least one person whose job is to deal with the technology. There might be fewer of them, and they might be a weird amalgamation of sysadmin and web developer, but there will still be jobs for nerds like us who actually like doing this stuff.
Capitalism is inherently broken if people don't get paid wages, because then they don't have money to buy stuff. Fortunately, capitalism doesn't need to exist forever
vs
"I want to pre-sort during idle time so that I can effectively implement a binary search"
You can tell me either of these and get the same product. You can pick one of these and tell an LLM to do it three times and get three different products.
Sorry, this cope.
Now, this may be acceptable (tons of businesses are built on broken products), but what is absolutely cope is this moronic idea that the LLM is always smarter than the average engineer and will magically produce the most efficient and correct solution.
Yeah but the person you're replying to isn't gonna see that because they already made several assumptions about the problem I put in front of them
And if I still want professional help then there will be a excess of labour due to the above for most tasks.
Disagree.
What is worse is having to learn and do it yourself because the people you hired won’t do their job properly.
Waiting = not paying attention to the issue = nobody cares (unless it’s some emergency). So what if your taxes are done two weeks later??
We'll be fine. Move to a lower cost of living area, start a business. There's millions of companies in need of software expertise.
All this moral panic about software work is unseemly. Maybe the easy "learn JS/frameworks" path to wealth is closed. Whatever. Good, actually.
We'll be fine, we're the most prosperous worker class in the history of working.
Besides the job never was churning out code and if there was a bloat of such positions it was only ever a temporary distortion.
This reminds me of that viral clip with Ben Shapiro saying that if the sea levels rise, people will just sell their homes and move. The clip went viral because of the response: "Just one small problem. Sell their houses to who [sic], Ben? F*cking Aquaman?"
> All this moral panic about software work is unseemly.
You know, it's funny how the history keeps repeating. This will be far from the first time a technological breakthrough left a group of people obsolete and scrabbling to deal with it.
Every single time this happens and ends up being a net positive for the society, the suffering of those people is ignored at the time and then we eventually look back and end up expressing empathy for them. And every single time we express hope that maybe next time we can do better as a society.
And every single time it happens, we not only fail to do better, but we have people condemning the very idea that we should even try to do better.
> Maybe the easy "learn JS/frameworks" path to wealth is closed. Whatever. Good, actually.
Wait, I could have easily amassed wealth by "just" learning "JS/frameworks"? Wow, and here I had the wrong idea about the causes of wealth distribution inequality. It's clearly those parasitic JS devs' fault.
What's going to change is that we'll have to focus on the actual hard problems of software development: making sure the software does what it's supposed to, isolating nontrivial bugs, finding ways to make it perform better.
These are exactly the things LLM's outperform all of us on.
If you've tried to build anything nontrivial with LLM you know this just isn't true.
Why is much of our legacy software suddenly failing us if we are so much better at finding intricate bugs than the LLM's? Why are all of us easily capable of speeding up our software by orders of magnitude in small amounts of time utilizing them. Yes, they are better at verification as well.
I share a similar experience with bug finding; I think it also helps that LLMs can simply hold much more context at once than a human, as seeing a much larger portion of the codebase simultaneously makes it much easier to spot discrepancies.
As for legacy software suddenly failing us, what you're really talking about are active systems like Microsoft 365 (it's not legacy code). Those systems have always been complex. That they are "suddenly" failing could be an indication of a number of things, but I'd pin a large part of the responsibility on organizational debt (even beyond technical debt). Maintaining complex software systems is hard, software mostly isn't a static thing it has to constantly evolve. It could also be an indication of over-reliance on LLM competency, for all we know about those system's internals. We just don't know enough to make an assessment.
There have been some zero days discovered by LLMs. There have also been many socially engineered, regular old exploits that have been impressed on us as indications of AI breakouts.
As for speedups, most software is comically unoptimized and has been for some time. We made an explicit trade-off in software development as CPUs and machines got more capable: we started coding in simpler languages with higher levels of abstraction (Python, Ruby, JS, Java, etc) sometimes costing us 10x or more in resource utilization, in exchange for the iteration speed that bought us. Converting those to more efficient languages like Go, Rust, C, etc alone buys you so much. On top of that, there are a number of algorithmic optimizations most developers never implemented that map to well known access patterns in hardware. Lots of low hanging fruit.
Examples are: Note taking apps, voice recording apps, calendar apps, video games, etc.
They'll shove out a pattern quickly, but no matter how new and magical the latest model is, they will just put out some tweaked variant of existing designs. I find myself treating it like a junior-mid engineer. "Add rdtsc-based timers around major parts of the code to whittle down what's taking too long." "Use that to figure out where the transfer amount is way too small to justify the time taken without copying the payload." etc.
But concurrency bugs from large LLM-developed codebases are a major issue. They constantly find bugs they wrote. I eventually told it to start writing formal models of the concurrent uses and to (a) validate the models; (b) verify the code implements the models; to make it work.
So yeah, I stand by my words. For simple commands and tiny codebases, it /can/ do those things, but even small projects (50 KLOC) are a mess of making it fix its own mistakes, reconcile basic logic in requirements analysis, and everything has to be taken over with a fine-tooth comb to make it any good.
If you don't specify the model you are talking about, you have written a sentence with near-zero information content. If that's your habit, well... that's likely part of the problem.
I promise you, Fable and Neon are better than you are at pretty much whatever. Sonnet 4.X and MechaHitler, well, maybe not.
In a similar vein public clouds contain the components to built any software you can think of. But that doesn't mean that all the solutions possible spring into existence just because AWS exists.
The tools are amazing, but I think they are most amazing when you can have deterministic verification loops. Async bugs aren't always encountered, so it's a little more difficult for the LLM to prove its work and iterate. At least, that's my current hypothesis for why it tends to degrade so much for this type of problem.
If you throw an excessive amount of money at the problem yes.
Wages might decrease if the work becomes easier and more people are able to do it, but I'm not sure jobs will actually go away until true AGI.