Companies are already bloated, imagine when they realize one overworked highly paid senior can replace 10 juniors.
A lot of projects today are not even greenlit because they would be too expensive to make. For instance, there are a lot processes in almost every country that require you to file paper forms, even though we have had web forms and databases for 25 years. This goes even for rich countries. If one programmer is able to do the job of 5 others, we will probably have 5 times as many systems to tend to now that businesses and institutions can afford them.
The only reason it's not the case in this example is because computers at the time were a tiny early adopter niche, which massively multiplied and expanded to other areas. Like, only 1 in 10,000 businesses would have one in 1950, and only big firms would. Heck, then 1 in 100 million people even had a computer.
Today they've already done that expansion into all businesses and all areas of corporate, commerce, and leisure activities. Now almost everybody has one (or a comparable device in their pocket).
Already cloud based systems have made it so that a fraction of programmers and admins are needed. In some cases eliminating the need for one altogether.
There are tons of other fields, however, more mature, where increased productivity very much equaled job loss...
Notice that during that time there weren't all of a sudden less programmers, or managers or sysadmins, if anything there's more. If anything everyone is even more stressed with more to do because of the context switching and 24/7. That's why this will do, I'd bet money on it.
Yeah. Also, unfortunately, it turns out those people in the 80s and 90s got it right. They didn't really need a computer - they'd better off without one. But as soon as we got them, we'd find some things to use them for - mostly detrimental to our lives!
...And also over 100 bugs in the spec that governs communication between car systems: https://youtu.be/hXnS_Xjwk2Y?t=899 (around 15 minute mark)
And instead of the 97% unemployment our intuition tell us would happen, we're instead 30x as productive.
The same will happen when/if AI makes writing software far more effective.
Economic productivity simply means output per worker. So, we could make 97% of the US population permanently unemployed tomorrow, and as long as the AI replacement labor yielded equal or greater proceeds to the remaining 3%, we’d see a colossal increase in “productivity.”
That would be in the interest of the 3% to do (or attempt), which is what makes the scenario so scary.
Sure, there will be niche sub-industries that will be erased by LLMs, and people who have those niche skills will suffer. This has always been the case with technological advances. And always, it has not disrupted the economy.
What are S-curves.
The fear that technological advances will cause mass unemployment and destroy labour markets has been common throughout history. Yet here we are at full employment. Maybe this time is different?
I'm still a bit bummed about it, because just writing and structuring code is something that often brings me joy (and maybe your wife feels similarly about the actual translation work...), but at the end of the day, I realized well before all this AI craze that it really isn't the most valuable thing I do in my job.
Yeah. The problem is that there’s only one of me. All the rest of you are filling in for the other guy.
Increased productivity doesn't necessarily lead to overall job loss, but it will eventually in the area where the productivity is realized. Agricultural employment is a very clear example.
Yep. This is where I'm at in terms of personal armchair predictions of the future.
I expect the labor market will be tough for more junior software engineers in the coming years. This might indeed cause backpressure in the supply of new grads/new labor force entrants in this family of fields ("software development").
However, the "highly paid senior" is only around for so long before achieving financial independence and just not working anymore. Then what? The company didn't hire juniors because the "highly paid senior" did all the work. Whoops. Now the company lacks the pipeline of people to replace that senior.
It'll sort itself out in time, but the next decade will be interesting I think. Some companies will realize that they must make investments into the future of the labor force and will do better in the longer term. Other companies might indeed "fire the juniors" for some short term gains and find themselves lacking replacement staff later.
Now some might say that the code will be terrible quality and buggy and full of holes and the users will hate it, it is never economically viable to build enormous systems on a house of cards like that. To which I respond, you just described every piece of enterprise software I've ever used ever.
I've seen entire businesses collapse because of this mentality.
i mean, unless your competitor produces order of magnitude less bugs than you, how can this be true?
I don't mean to sound mean, senior devs are also secretaries of their cto and so on.
Getting juniors un-stuck on "simple" problems, maybe. Stack Overflow already does this. Image doesn't build? Search for the error message online. Don't know how to build the old software that only works in Ubuntu 14.10? Sure, you'll find that.
Suggestions on how to refactor, proper design of interfaces, what skill to acquire next? Maybe, but that will be a bigger surprise.
Every org has varying level of engineers. This technology will make cheap grind, well cheap. We see the progression. With the speed of changes it seems we should all be worried. (as why does it matter despite being last we fell a year after)
That is already possible without AI and has been the case for a long time... the issue is nobody will stay to be that highly paid senior running entire projects because at that point you can just run your own shop and pocket the full profits.
I'm not disagreeing with you. Im thinking of going solo myself.
Not to say that this is a bad thing, but the difference between a junior and senior is often much more than the difference in their salary.
Except, there was no AI, but an alternative called an offshored development center. You would send your spec and design document and get, via email or FTP if they were really cutting-edge a number of files that would sometime compile and even, according to the legends, actually work. The way this tech worked is that you generally had to wait overnight for your spec to "mature" into code.
Some places figured out they could hire local engineers for about 5-10x what they paid for this "offshored development center" tech and get better results.
This already happens, the market is just not very efficient about it, e.g. a highly paid senior dev is not working at a company that only needs 2-3 developers, they're working at Google with 100's of devs.
I remember after ruby on rails first demo, next day people had their websites up in ror. Here we will see, but it will be a bigger shift.
Developer time reduced by 5X CPU time increased by 500x
When CPU cycles are cheap it's a logical tradeoff but it still grates against my sensibilities.
You know you can call import functions and call libraries in other languages than python? If everyone was programming in assembly then there would be plenty of libraries to make database calls or make web servers in assembly, and there would be plenty of tutorials online that you could copy and paste to get things going, meaning it wouldn't take much work at all. It would be more work, but not orders of magnitude more work.
If an inefficiency saves a developer 10 days of work, but results in an operation taking 100 milliseconds longer, and you have 50M customers who do that operation just one time, then you've wasted ~58 customer-days.
It makes more sense to tune libraries excessively, we could say it is less of a trade off, more of an allocation of the finite low-level tuning developer resources to high-impact libraries.
Anyway it turns out that the only way to get most people to link to a good BLAS is to use Numpy and distribute it through some giant Anaconda Rube Goldberg machine, so, I dunno, people are weird.
It's some kind of philosophical question.
Maintaining an assembly version of a modern software stack is not 5x more costly, it's simply not possible.
I mean, I already do? And for totally mundane and benign reasons. This has been my experience in this industry for the last 8 years or so, though my first 9 years I felt like the pace was maintainable.
Do more with less. It's so common to come across situations where so and so left, their position won't be backfilled, the targets don't adjust to compensate for the productivity hit, and we can put up or shut up.
Additionally there’s the math behind it. If Company A fires 50% of their staff because AI lets the remaining 50% work at twice the productivity then how will they compete with Company B that keeps their staff and now gets 200% efficiency?
The math is in favor of getting more, not fewer, developers.
You know how hard it is to start debugging a project you haven't been onboarded to? Now imagine that every time something has a hiccup.
Also, if your one programmer dies you now have no programmers and loss of all institutional knowledge, whereas the other company can lose several programmers and still be OK. There is value in having redundant programmers.
If they indeed wait for input from other departments/companies 99% of the time (so they just need to actually program 5 minutes in their 8-hour workday), then they can be already thrown out of a job and have the company do with 1/10 the programmers, no AI required...
AI wasnt needed to cut down on bloat - some combination of a few companies reaping the majority of the profit and reduced dysfunction is enough.
If one can go the job of 5 - they revenue per employee will increase.
They will hire even more employees.