I wouldn't consider myself an SWE, just an amateur programmer, so this is an honest question: In your opinion, is there such a case where the usage of AI in software engineering has either sped up the dev time or improved product reliability (or even both)?
There's things it can do, so long as you use it as your complement, i.e. all the stuff you know is important you just go "ugh" when faced with. For me, that means unit tests. I can write them, I know why I should write them, I have professional experience with them, I can judge which unit tests are useful and which are make-work and which have missed the point entirely, but I'd rather not be the one to actually write them.
LLMs can write them for me, and I can happily look through them to make sure what the LLM made was neither brittle, nor testing unimportant things while missing the important stuff.
They can also help with code review, but only to a limited degree; a second pair of eyes to avoid lazy people going "LGTM", or the other way around time-wasting feedback from bike-shedders, but as with unit tests, right now you still need to be the kind of person who is happy to double-check its work — if you're the kind who was previously a little too quick to accept pull requests with a "LGTM", you may well be too willing to listen to irrelevant bike-shedding from the LLM or not realise it is missing the point of the code or the ticket.
But if you use it to replace the stuff you're already good at, and not help with the stuff you're weak at, it'll probably slow you down while also making the code worse.
> Millions of programmers out there, and you're saying there's not even a 1% chance that a single one of them is moving 10x faster
Would that mean that every other claim to be moving 10x faster is an exaggeration? It evidently is, as these claims of massively increased productivity are purely anecdotal.
If the claims were ‘5% productive across the board’, it would be huge, but 1000%? That is a ludicrous tall story that requires extraordinary proof.
My point still stands, the author is confidently stating something that's clearly just wrong. The alternative is that everyone is creating tech debt 10x as fast (while being completely oblivious to it.)
It's pretty obvious that's not what's happening. To pretend otherwise would suggest that every software developer everywhere is completely unaware of what tech debt is AND that they don't care at all.
Again: it's obviously wrong if we think about it for longer than 5 seconds. This is just pure emotional cope.
That's a pedantic word game. The industry at-large doesn't track lines of code as a measure of velocity. So, yes, faster does mean more productive, since that's what any sane programmer means when they say "I built it faster". They don't mean that they literally slapped the keyboard faster than someone else.
And yet "slapping the keyboard faster" is all that AI does. It doesn't design architecture. It doesn't think. It doesn't reason. All it does is search for and copy-paste code from elsewhere on the internet. If you're lucky it might even be code that works and does what you want it to.
It can do that. Won't say it's amazing, but it can do it.
> It doesn't think. It doesn't reason.
Can you define these in ways that aren't tautologically limited to humans? I have yet to encounter anyone who has managed this while making such an objection to any form of AI.
> All it does is search for and copy-paste code from elsewhere on the internet.
They provably don't work like that. Both because local models exist, can be run offline, still spit out code to solve problems; and because some world records have been set by them, for some CS-related maths problems the best known method was invented by an AI which used an LLM as a component.
I don't know if it's 10x, but there's definitely a huge acceleration in productivity. Attempts to deny that are basically just cope, or perhaps from people not using the tools correctly.
If I may ask: In what areas have you found the most acceleration in productivity? For me as an enthusiastic amateur programmer (whose enthusiasm is, arguably, greater than my technical abilities) the only reliable and sustainable way to use AI in building software is to treat it like an exceptionally knowledgeable (though not perfect!), infinitely patient tutor that guides me through programming problems I run into.
The minute I relinquish control and let it just write code for me I am doomed because AI cannot fix its own mistakes in anything of medium complexity or above - and then I have to dig down and try to understand code I haven't written which is, in my opinion, worse than having had to write it myself in the first place.
It's very good for bug fixes. I paste the log into the agent, and it has a good chance of suggesting the fix. I have to review it, but it has been a big time saver.
For new code, I treat it like a very knowledgeable mid level engineer who has a lot of patience to search the code base. We make changes a step at a time and I review them carefully and have it make changes I want. It's still a lot faster than doing it myself.