Theres a fundamental minimum amount of boilerplate you just have to write to make a functioning app, even if its simply just describing "this thing does this"

For example, if Im making a web api, theres just fundamentally a chunk of boilerplate that wires up "This http endpoint points to this domain logic over here"

And then theres gonna be some form of pre-amble of describing "it takes in this input, it returns this response, and heres all its validation"

And while its simple code, and its very simple to test, its still a buncha LOC that any half assed dev can write.

Stuff like that AI can shit out very quick given an input requirements doc that you, the dev, were gonna get anyways

And then you, the dev, can fill in the actual logic that matters after all that basic boilerplate stuff.

"Yes, it has a phone number input, its required, and it must fit the phone number regex we defined. So... shocker, you gotta put a string called PhoneNumber on the inptu model, and another shocker, its gotta have the phone number validation on it and required non empty string validation on it"

It doesnt take much trust to put into the LLM to get that sorta stuff right, but it saves me a whole bunch of time.

Pretty much, its the actually important code you wanna pay attention to.

The majority of code is just connecting pipe A up to pipe B, its honestly fine for an LLM to handle.

The job security comes from, as a developer, knowing which code goes in the 90% bin vs which goes in the 10% bin, being able to tell the difference is part of the job now.

Yeah, and it moreso moves a lot of your work over to other important stuff.

Namely, planning things better, reading, documenting, and coming up with more specific scenarios to test.

Before, because Id spend an extra chunk of my time on that 90%, maybe my documenting would be mid at best, stuff would slip through, my pile of "I prolly should get around to documenting that stuff" keeps growing and growing.

And then while maybe I can vaguely think "yeah I bet theres edge cases for this stuff I didnt make tests for", its followed by "But I dont got time for that shit, I have to have this done by end of day"

Meanwhile with LLMs, I can set it off to cook on that 90% chunk of work, and while it's cooking I can chat with another LLM instance and back-and-forth iterate on "what are some possible gotchas in this logic, what are edge case scenarios to test?" and by the time the agent finished coding, I have like 20 edge case test to copy paste over to it "Hey, make tests for all these cases, make sure those all work as expected "

It shifts my focus over from just monkey work to stuff that matters more, finding and poking holes in the code, trying to break it, making sure it withstands stress and edge cases, and finding possible gaps and flaws in it.

When you focus like that, you definitely become way more productive.

As opposed to people who just give up and, yeah as you said, just are lazy, they hand off the work to the LLM but arent making up for that by redirecting the energy to other places of value, they're gonna go, I dunno, run a raid in WoW or something fuck knows.