[msdz]

> LLM’s amplify what you already have: opinions, structure, frameworks.

So far, so agreeable, but…

> If you have thoughts, they come out sharper and faster.

I can’t help but wonder whether constant use of “agent” harnesses will lead to an atrophy of the software engineering (or really any field) muscles.

Actual muscles need exercise to stay in shape (let alone grow), so does the brain. Can we really be sure that thoughts, opinions, taste will still come out sharper and faster after five, ten, 20 years of using these tools almost every day?

Conversely, I also am a user of LLMs (true shocker these days, I know), and am noticing a speedup in areas I was already familiar with, and a quicker introduction to new ones. The obvious benefit cannot be denied, and doing so regardless makes you look uninformed. [0]

So what’s the ideal “middle ground” in this situation? Stoically continuing to sharpen your skills on your own, but risking being left in the dust productivity-wise? Or taking an “agent first” approach and trying to learn and improve more only on the side, as more of an afterthought?

[0] Excluding people who don’t want anything to do with LLMs out of moral principle, which curiously just like the overarching topic I also both respect and understand, but on the other hand don’t do myself.

[Diogenesian]

I will just point out the benefit is not as obvious as you think. Developers have consistently overestimated LLM productivity gains, which still seems true for agentic AI: https://metr.org/blog/2026-05-11-ai-usage-survey/ It is particularly striking how similar the results are to LLMs before agents.

Along with the total absence of long-term data, I think the benefit can be (weakly) denied. Maybe not in the employmemt marketplace, but certainly for myself.

[qsort]

> I will just point out the benefit is not as obvious as you think. Developers have consistently overestimated LLM

I think there are two different claims here:

- developers overestimate productivity gains, which is a solid finding in many of these studies. Skepticism of extremely large productivity gains is warranted and I flatly disbelieve "10x uplift" claims.

- LLMs give no productivity uplift at all, which is much harder to defend. A repeat of the famous METR RCT study did find evidence of improved productivity, and this seems to align with the experience of many experts I trust.

[Diogenesian]

Specifically my claim is "the relatively minor productivity uplift I would personally get out of agentic development is offset by the high cost, along with unresolved questions about long-term code maintainability, so I am not convinced that it is actually beneficial."

IMO the bigger problem is that ~1.5x individual dev productivity uplift seems to translate into 1.05x uplift across the team. People have been waaaaayyyyy too overconfident about this stuff.

[breadzeppelin__]

I am both a career developer and experienced team manager. from first hand experience the 1.5x im getting from AI is not flowing down to my team / org because why would i output 50% more when the pay environment and leadership are already underwhelming. That additional 50% productivity goes completely to side projects built on my second computer between 9-5 tasks

[Diogenesian]

Actually, the METR report speculates that some of the overreported productivity uplift comes from grabbing unnecessary low-hanging fruit, things like "oh I'll make a web dashboard to keep track of this stuff // wow that would have taken all day without Claude!" But in the olden days they would have just used a notepad. Yet psychologically they built a real thing and saved a lot of time.

[breadzeppelin__]

True I have made a few low tier apps that just hit apis that were previously obfuscated deep in menus that have had an outsized impact

[thaumasiotes]

> But in the olden days they would have just used a notepad. Yet psychologically they built a real thing and saved a lot of time.

There was an old Onion article about the monetary savings from buying clothes on sale as computed by (a) the women buying the clothes; and (b) their male relatives.

[dawnerd]

That’s what I’ve heard from my dev team too. They’re using it to give themselves free time while still being on the clock, not to produce more output for the company. Roughly thinking about hours spent on projects I think have gone up per task, the opposite that should be happening.

[strken]

I'm finding it almost impossible to fill that free time with work, unless it's just reading emails and chat messages.

I can context switch between two or three chats, but doing so speeds up my agent use at the cost of making reviews and discovery harder, so it might come out in the wash.

[dieselgate]

Your comment makes total sense to me but generally, in regards to productivity gains from AI, I can never understand where these are realized for people. Maybe I'm just a laggard but never found myself 25%-50% behind on anything or that much more work/items/tickets available.

[ra0x3]

Great point. Devs have relatively no incentive to be more productive for their orgs, and all the incentive to be more productive on their own personal work. The AI benefit to devs is real, just not for large enterprises IMO outside of automating clerical/mundane work.

[Aurornis]

> Devs have relatively no incentive to be more productive for their orgs, and all the incentive to be more productive on their own personal work.

AI definitely supercharges the side project myth, but I think we’re going to see waves of developers quitting or losing their jobs because they’re chasing dreams of running a side code project that isn’t going to turn into a business.

The incentive to be more productive at work is that they get to keep their job and not be replaced by a cheaper junior. I think we’re in for a reckoning across the industry as companies realize that there’s little difference between a lazy senior armed with Claude and a halfway motivated junior who has aspirations of growing into something more. The latter costs less and might grow into a better dev.

[Aurornis]

> because why would i output 50% more when the pay environment and leadership are already underwhelming

The productivity uplift measured in some of these reports is from more tasks being done, not from developers giving themselves more idle time during the day.

If we do see job losses from AI, my feeling is that it’s going to be concentrated in people with an attitude like this one where workers try to remain anchored to their old delivery pace. It’s becoming easier than ever to replace a worker in that position with a lower paid junior equipped with Claude who has an interest in learning. There’s no reason to keep a higher paid worker around to copy and paste between Jira and Claude.

[thin_carapace]

thats absolutely true regarding wysiwyg projects like a small website. aside from temporary cost savings, systematically ignoring institutional knowledge in favor of mass output is not gonna do humanity any favors ..

[alanwreath]

Could it also be that the phrase “using an LLM” is loaded in itself? Who is getting more velocity out of it:

- chat box interaction

- vendor harness user (the cursor / antigravity crowd)

- SDD Claude users

- bespoke harness creators who let it goooooooo

I mean we already know who’s using all the tokens and driving enough cost to make penny pinchers consider removing other “costs”

[bigstrat2003]

I have seen no productivity uplift at all from LLMs. They are at least about neutral these days (they used to be a productivity drain), but no gains at all. By the time I get done reviewing the code to make sure it hasn't done anything crazy, I've spent the same amount of time I would've taken to write the code myself. The only people I personally know who claim productivity gains are getting those gains by completely disregarding quality, or understanding the code, and just YOLO letting the LLM do everything without checking. I'm not willing to do that.

[annzabelle]

I find Claude is shockingly slow. If it were genuinely instantaneous, it would be worth it, but I often find myself twiddling my thumbs while waiting for it to cook.

[fragmede]

Yeah that's why you do multiple tasks and projects simultaneously.

[rwyinuse]

Humans notoriously suck at context-switching. I doubt you can really do multiple projects simultaneously without compromising quality.

[Hugsbox]

That sounds like a really efficient way to very quickly produce a mountain of crap.

[skydhash]

> LLMs give no productivity uplift at all, which is much harder to defend

It’s not really hard to defend. Because when people says that productivity is uplifted, they are talking about amount of work, not the ROI. That’s why you keep hearing about LOC, amount of PR and prototypes, and the time taken is actually “time to PR” and not “time to production + time spent on bugs”.

[tpdly]

There's another even more abstract liability on the balance sheet here for "deprecated LOC" or something, where the thing they built gets scrapped because no one wants to untangle the rat nest, or the "documentation" was so incoherent that it all had to be rewritten and reviewed.

[ctkhn]

Coming from legacy enterprise I am using claude to do exactly this for some of my team's more bizarre and poorly documented "inventions" that started out as their pet project and then became part of our official workflow.

[GuB-42]

Maybe we can make an analogy with taking the plane vs driving to your destination.

A plane literally goes 10x faster than a car, so a 5 hour drive becomes a 30 minutes flight. But if you have to drive to the airport, arrive early, pass check-in, security, boarding, then pick up your luggage on arrival, rent a car and drive to your destination, you may realize that your 30 minute flight took you more than 5 hours in total.

You also have to consider the Amdahl's law: a 10x speedup on 10% of the project is just a 9% speedup overall.

[ctkhn]

> You also have to consider the Amdahl's law: a 10x speedup on 10% of the project is just a 9% speedup overall.

This is totally true for me. I'm working on more features/bugs at work and getting the coding done faster with claude but the coding part is at maximum half of the process and usually less. The rest of it is clarifying the requirements from our product team or given that we're a very legacy place, what the existing state of our infrastructure and other systems are for the new changes to fit in to, etc.

[thaumasiotes]

> You also have to consider the Amdahl's law: a 10x speedup on 10% of the project is just a 9% speedup overall.

It's a 10% speedup, unless you think that a 100% speedup would reduce completion time to zero rather than cutting it in half.

Assuming that "10% of the project" is measured by time requirements, when you get a 10x speedup on that part of the project, you'll end up completing 100 units of work in 91 (formerly 100) units of time. Your work rate is then 100 / 91 = 1.099 times what it was before; that's an improvement of 10%, not 9%.

(Sanity check: suppose you have a project that will take 100 days. That project is reassigned to someone 10% faster than you. They will take 100 / 1.1 = 90.91 days to finish.

If they were 9% faster, they'd take 100 / 1.09 = 91.74 days to finish.

Does a savings of 9 out of 100 days of work look more like the project that saves 9.09 days, or the one that saves 8.26 days?)

[bodge5000]

In the former case, which seems more likely, does it not fall to reason that like any tool there'll be some that will benefit from it and some that it just won't work as well for, but are equally as good at their job? Like that neovim, unless your an absolute zealot you wouldnt insist that everyone use it, or hire someone based off it, but those who do work well with it do find it to be a boost to productivity.

Also importantly, can it be a neovim? Neovim hasn't had literal trillions invested over it in the space of just 5 years, local llm's aside can those smaller productivity gains justify the huge investment put into them, and which will continue to be needed for further model development?

[deadbabe]

Developers are cashing in on the productivity gains. Meaning instead of using the increased productivity to do more work, they just become lazier or do fun irrelevant side projects instead, where as before there was just not much time for such things. I have definitely procrastinated on work simply because I know I can swoop in with an LLM and do it all in 15 minutes, whereas before I would have spent a few hours.

This is how LLMs can both result in greater productivity yet still not appear to yield much more benefit than the pre-LLM era.

And there is no benefit to the developer for doing the work first then just sitting idle. That’s how you get people putting more things on your plate.

[jdjdkfhbeb]

I would frame it differently ... Last year I was burning the fuck out hard. This year I am not.

My gain is that I produce good work in a normal workday and I am absolutely not writing code to 4 am anymore...

Overall for me it is a win for me and my company.

[Grombobulous]

Some unsolicited, probably obvious advice for you for the future: never do that again.

Managers will abuse you if you expand your workday to make sure deadlines don't slip. They will see that the work is getting done and see no urgency to hire more help.

You have to surface capacity issues to management, learn to say "no" diplomatically, and/or "I have capacity for 2 things out of these 5, prioritize which ones you want first."

[hexasquid]

The LLMs are better at enforcing their boundaries than developers. Run out of tokens? That's it. No more code. It doesn't care how much the company needs this for the customer call tomorrow.

[deadbabe]

Odd, it was the opposite for me. Last year, no burnout. But then agents got good and everyone wanted more code more features faster and faster. I got burnt to a crisp. Now? I don’t give a fuck. Ok people want to push tons of code straight to prod? Go ahead, looks good to me… no need to review it if it’s with the latest frontier models right?

[anon7000]

Exactly, I finally migrated that old service to typescript and cleaned up some really annoying tooling, for example. I’m more productive and can get quick fixes out very quickly. We’re also seeing agents help identify incidents faster than human investigation can. But big structural things that are hard to integrate still take lots of time.

[mcv]

A few months ago, I heard a keynote speaker claim that LLMs did not give any measurable productivity gains, except in two fields: customer support and software development, where they resulted in about 30% productivity improvement. I forgot if he presented any sources, and if he did, I forgot those, but it sounds plausible to me.

But instead of productivity, I'm much more interested in using it to improve quality. You've got a tireless reviewer who is always ready to review your code and catch any gaps.

[Hugsbox]

I don't know how they're measuring productivity for customer support, but it certainly isn't in terms of customer satisfaction. People have never been happy with chatbots when they're trying to reach a human.

[sethammons]

We are getting ai responses from cloud providers. From both aws and google, my teams have received obviously ai generated and non-applicable advice.

The latest was that we need to write in object pooling in their client code, an option that doesn't exist yet in _their_ client code. Like, yo, that is a you-problem on performance bottlenecks; we expect you to provide solutions.

[deaton]

I think the real disaster is that once you let the LLM work on a project for a bit, you start to lose understanding of what exactly is even happening under the hood in the project. You can take steps to mitigate this, but agents don't exactly encourage the behavior required to maintain a good understanding of what's going on.

[westurner]

Like becoming a manager?

When a person becomes a manager, they do or do not have enough time and expertise to review all of the code that they trust the team to produce.

Managers usually get into automated testing; unit tests, integration tests, acceptance tests, and maybe also BDD syntax

Managers and developers are responsible for setting a test coverage threshold for merge approval.

If there is 100% branch coverage test coverage for a codebase, what would coverage-guided fuzzing or property testing find? If there is 100% branch coverage test coverage for a codebase, what is the value of spending resources on formal verification?

How does the value of LLM-produced 100% branch coverage compare to no-LLM 100% branch coverage?

[BalinKing]

I've never really understood this argument. If someone's a manager of an incompetent team, no amount of management skill will save the quality of the resulting software. I don't think "just treat LLMs like smart junior developers" fixes this, because well-functioning teams usually also have senior developers to keep things on track. Like, if we handed a team of genius-but-junior developers to the best "people person" manager in the world (i.e. who doesn't actually read the code), would we really expect decent results? Even if the manager tested the code by hand? I honestly don't think so, at least once the software gets past a certain (fairly low) threshold of size/complexity.

[westurner]

If you have a "this is an incompetent team" attitude, that's what quality software you'll get back; whether or not there's LLM use.

If you have a "I trust my competent team to write good enough tests and test coverage isn't my responsibility" attitude, that's what quality software you'll get back.

There are people producing good and excellent quality software with LLMs. Presumably you must discard low-quality code in order to maintain quality.

There's certainly a limit to code quality with current models. On number of lines of code per unit of time, LLM tools certainly already win.

Can costly automated code review for PRs catch most of the problems before they're under consideration for merge?

For example, the vscode repo has extensive copilot integration. Every PR gets auto code reviewed. But with their tokens or the contributors'?

If I take poor quality code (AI-assisted or not) and spend a few hundred dollars on tokens for a next gen model and agent to get to 100% coverage and review for security bugs and CWE common weaknesses, what quality code will I have without refactoring with proven patterns and type annotations and polishing docstrings?

[jagenabler2]

I don't think this argument holds. The OP made the very good point that most quality software teams are composed of both seniors and juniors, with the seniors (and even staff members sometimes) drawing the lines so that the system stays on rails.

If you're a manager now and your "team" is a bunch of coding agents, those agents are hardly junior engineers at best. It is equivalent or even worse than hiring a team of 3-5 junior engineers and letting them run rampant with your code.

[deaton]

> If you have a "I trust my competent team to write good enough tests and test coverage isn't my responsibility" attitude, that's what quality software you'll get back.

As much as this sentiment is nice, it is completely divorced from reality, unless the competence is verifiably there. If you take a bunch of juniors and say "yeah I trust them to do everything well enough," you're going to have a disaster on your hands.

[tablarasa]

> How does the value of LLM-produced 100% branch coverage compare to no-LLM 100% branch coverage?

This is such a salient question. Sometimes (definitely not always) the test suites produced by LLMs are so trivial it's scary. Coverage can be an illusion for sure.

[coldtea]

I have been seeing such trivial shit getting submitted and deleting them from the test suites, but it's disheartening to see that the devs didn't have the better taste to see those LLM "tests" are so trivial they border on noop before submitting them...

[westurner]

What new or existing metric would better assess test coverage than line coverage and branch coverage?

I wrote a tool called tert - I guess it's called an agent harness now - to run various test runners and log test output and coverage output to disk. FWIU stripping spaces from JSON does save tokens. It seems like feeding coverage lines-missing maps into the prompt results in better output, better LLM-authored tests.

"Refactor these tests for maintainability and coverage. Use fixtures, mocks, and parametrization"

[mkw5053]

We try to use types as much as possible. And if we can't, then lint rules, etc. Basically, get everything as far left in the SDLC as we can.

And, if/where we need tests, we write the source so they are few, high value, and complementary. Like actual unit tests, not complex with stuff like mocks just to generate trivial coverage.

[pjc50]

Formal verification is always more valuable than mere testing, but it's hitherto more expensive. The thing that ultimately matters is closing the loop: how well do the tests match the requirements, both as written and as unwritten in the mind of the customer?

Working with an LLM has given me a real eye opener on unwritten requirements. It's like outsourcing. "Yes, you've given me what I wrote down, but I never expected you do to it in that way"

[westurner]

Causes of failure; Operator skill, prompt insufficiency, model insufficiency, agent insufficiency, insufficient code review, overloaded merge maintainer

[skydhash]

> When a person becomes a manager, they do or do not have enough time and expertise to review all of the code that they trust the team to produce.

> Managers usually get into automated testing; unit tests, integration tests, acceptance tests, and maybe also BDD syntax

I can see managers getting involved into acceptance tests, but never in the other type of tests. And the verification mostly is involved into a quick manual testing/watching a demo. Code is not their concern. When there's a bug, they expect you to investigate and fix it.

[westurner]

Given that it's so easy to generate better than test stubs with a model and manually review what it thinks covers, I think it's fair to expect a manager to run and add to the tests.

If devops has done their job, it should be trivial for a manager to contribute to the tests and run the build on git push (or manually re-run the build with the web UI).

If a manager has deploy rights, they should be able to run the tests.

[astrange]

Managers often still have code and team-lead responsibilities IME. First-line managers, that is.

And then sometimes you report a memory leak and it gets fixed by a VP and you wonder if he doesn't have something better to do.

[brabel]

If the memory leak could cost the firm its reputation with important customers, then I doubt the VP had something better to do.

[exe34]

I think what this fails to cover is that managers rely on other people to do that understanding and keeping things in mind. When there's a problem, the manager isn't just saying to a random person "go fix this", most of the time they're relying on somebody who has a deeper understanding of the problem and is not likely to randomly break something else just to fix this one bug.

[westurner]

Fearless refactoring is possible given test coverage? True in my experience; both with higher-risk human-developed software and with agent-coded software.

I haven't yet made myself learn the new swarm of concurrent agents with different specializations/agent_instructions methods yet.

Are multiple worktrees worth the cognitive burden and merge overhead?

A merge maintainer is always in code review mode

[pydry]

The productivity depends upon the requirements.

If slop is fine (and sometimes it is), the benefits are undeniable. If the dev was the kind that would have produced slop anyway - again, undeniable boost.

If the quality needs to be high I think it actually can slow you down, though.

[someoneiam]

Agreed, but also to expand, if the dev is mediocre and ai-assisted coding is a skill, the productivity gains are 10x more mediocre code. Since code is a liability, this is not desirable. Hence, mediocre devs being more productive is an underestimated problem of the age of ai-assisted coding. I see this every day.

The result is a whole bunch of dysfunctional systems unnecessarily dislodging perfectly acceptable processes.

[ermantrout]

"Code is a liability" is the part that usually gets hand-waved, and there's a number on it now. Veracode's 2025 GenAI report ran 80 tasks across 100+ models: when a task could be solved securely or insecurely, the models picked the insecure path 45% of the time, at roughly 2.7x the vulnerability density of human-written code (Java was worst, at a 72% failure rate).

So the mediocre-dev case may be worse than "10x more mediocre code." It's more code that also skews insecure by default, and that cost shows up downstream in review and incidents, not at the PR. Throughput goes up, and so does the liability per line.

[iugtmkbdfil834]

<< So what’s the ideal “middle ground” in this situation?

Putting all this in 2nd paragraph so that you can skip it if you think 'coding' is your primary portion of your job.

I suppose I am in a mildly privileged position in a sense that my work is a weird intersection of tech, finance, and comprehension. In other words, I don't code much, but I absolutely benefit from now being able to play with various projects I would otherwise have no business touching without a bigger support team.

I don't want to invoke Accelenrando, but the muscle imagery and analogy fits. I will give an example. I recently decided to pick up Go for a project ( have experience in some other languages, but I will still be starting fresh ). I could have codex build me what I want, but I am purposefully taking it slow so that I can learn the foundation so that I can have a frame of reference ( because I assume it won't be the only go project for me ).

Otoh, most of my one off python scripts I barely even skim anymore. And honestly,that is the part that scares me more.

[AnimalMuppet]

Why would you be very careful with a one-off script? The only point is the output.

On the other hand, if you actually care about the output, how do you know it's right, unless you review the script? I mean, if all you care about is plausible-looking output, you could have the LLM produce that, and skip the Python script entirely...

[iugtmkbdfil834]

Eh, unlike some of my contemporaries, I am not as interested in merely plausible-looking output. I want good output each time, but I am clearly still trying to find a good balance.

[Levitz]

>Conversely, I also am a user of LLMs (true shocker these days, I know), and am noticing a speedup in areas I was already familiar with, and a quicker introduction to new ones. The obvious benefit cannot be denied, and doing so regardless makes you look uninformed.

My largest concern comes from something tangential to this: I'm not sure we're all that good at deciding what should be learned and sticking to it.

Silly example: regex. LLMs are, as far as I know, well above the average dev when it comes to writing regex. Regex is also one of those things that for many people goes unused for months, but then you encounter the occasional perfect regex problem, and it's really easy to just lean on the LLM to write the regex for you rather than spending some time tinkering and testing. Regex can be frustrating and fickle, I think we've all been there.

But then, you just don't learn regex. So where does the intuition for what regex can do come from? Do you just become unable to write regex with no LLM? People stop writing resources for regex I guess?

My concern is that there's stuff I feel I can just chuck onto the LLM but I'm sure my judgement is not perfect. It's still probably worth it, all in all, but I'm not even sure of what I might be losing along the way and that's an uneasy feel.

[xnorswap]

I've been using regex decades, but it never really stuck to do anything too complex, it was the perfect intersection of difficult and infrequent. ( And also variable - PCRE vs others customisations / non-regular parts, etc ).

I am very glad that I can now just ask claude for a regex to achieve my intent.

Does it mean I'll never master regex? Yes it does, but decades has shown that was unlikely to ever happen anyway.

[tonyedgecombe]

How do you know that what it produces is correct?

I’m wondering if by the time you have been explicit enough in your prompt you might as well have looked up what you needed.

The expression is always terse so it’s not as if you are saving much typing.

[km3r]

Automation. And i think that vastly overestimating the time it takes to write explicit prompts.

[jmartrican]

Regex came up so infrequent that I found myself referring to documentation whenever I needed to use it. But I always wondered, what are the jobs or roles that use it so often that they have mastered it.

[Terr_]

That's somewhat alien to me, I suppose because over the years I just never stopped using regex in search/replace tools, which is daily exposure regardless of what code needs to be written.

Sometimes the patterns are dirt-simple, like `/\bfoo/` to find things that start with foo, or a `/foo.?bar/i` to try to find multiple variations of FooBar and fooBar and foo-bar and FOO_BAR. Other contexts outside an IDE include browser dev-tools, exploratory SQL queries on the database, searching centralized logs, and occasionally turning lines of text into spreadsheets via CSV.

None of that guarantees deep expertise of the weirder tricks, but it absolutely keeps the general knowledge "warm."

[parineum]

anything with large amounts of user text input.

[rmarshallATD]

> But then, you just don't learn regex. So where does the intuition for what regex can do come from? The training data is there for regex and it's unlikely that regex will experience massive changes but your concern makes sense. I had to learn before LLMs handled that part, the "when to use this" intuition. My guess would be that the logical conclusion is dependence on LLMs to make that determination increasing over time, both for when and how to use regex, for better or worse.

[ambicapter]

We're talking about validating the regex, which you have to do with your own skills, while LLMs are still wrong, some of the time.

[fragmede]

In the era of vibecoding, there are people creating software that haven't ever heard of a regexp. I learned regexps when Perl was popular. It's a useful skill that has served in me well in my career, but if the industry's moved on from a place where regexps and Unix knowledge are useful because this new tool has replaced me, well shit. I'm excited for the future, but also that's not a great feeling to have.

[michaelsalim]

I love AI but one thing that is a bummer is: Skills that used to be straightforward but people generally never took the time to learn are now trivial with AI.

Things like regex and CSS are not that hard if you take some time to study them. People don't though. Now I don't have that advantage anymore since AI can do them so well. Or... Maybe that could be an advantage since there will be even less people learning it.

[jghn]

They were also easy to look up on the fly as one needed them too. So really really knowing them was never a true advantage. For me it wasn't that I never took the time to learn them. I realized long ago that it wasn't worth my time to keep that information in my brain, and I offloaded it to google 100% of the time it came up in my day to day life. Now I offload it to Claude, same thing.

[michaelsalim]

I do agree with that. I wouldn't say I really really know them either. I know enough to sound competent and be relied upon, and then I can google them to remind myself of the details.

[jghn]

I realized later you likely meant the latter anyways and yeah that's much different. It's important to know what these things are, how they work, and why one would need to tweak them. It was never important to have the syntax on instant recall.

[27183]

If you don't know regex--how to write them, how to use them, what they're good for, what they're not good for--what makes you think you're competent to review a PR containing one?

If you don't know how to regex and you let your imaginary LLM friend write one for you, and you foist that upon your colleagues for review, you've just abused their trust. Because they, being ethical, honest engineers, must now do all the work you neglected except they're doing it at review time instead of at the time of writing.

Or maybe they're dishonest and unethical and they'll just maliciously or negligently approve the PR without actually reviewing the regex.

Either way the situation is completely rotten. You can never ethically use an LLM to do something you're not competent to do yourself.

[Rumudiez]

Knowing what to learn has always been an implicitly vital skill to career growth. Maybe it’s all right fewer people will know regex, just like as each year passes relatively fewer people know about var hoisting in JS

What does the business benefit from you handwriting regex vs a clanker?

[skydhash]

The benefits of knowing regex is not about the syntax (that’s what docs/google/books are for), but knowing when it’s right to use it.

Immersion with the codebase is not about coding and syntax (which is actually very easy for me). It’s about being able to intuit that a particular combination can result in a buggy state and provides the wrong result downstream. You lose that you stay in the dreamland of specs.

[jghn]

That's fair. This all feels similar to the shift that happened when Google came on to the search scene. To use your example, people realized they no longer needed to memorize syntax. Instead they only needed to ensure they understood the big picture concepts, and they could fill in the blanks on demand with Google. This is all just moving that layer of abstraction one level higher.

[skydhash]

Not really. Before google, we had (and still have) books. What the internet and later google changed was the availability of information (If I had to rely on libraries and bookstores, I'd never be a programmer today). The job was never about memorizing knowledge, only the application of it. That has not changed since the dawn of computing.

[jghn]

Sort of. As a developer I had my stack of reference books, man pages, etc. I’d try hard to memorize syntax as it was a pain to look things up. And I also devoted some memory to remembering where in a book to look, which set of man pages to use, etc

With google that mostly went to the wayside. I just needed to know something existed and I could pull together far more information faster than I was spending before to just do quick lookups

I didn’t say the job was about memorization back then. Rather I found that each of these new abstraction layers made it easier to go broad with one’s on hand knowledge instead of deep

[ElFitz]

> I can’t help but wonder whether constant use of “agent” harnesses will lead to an atrophy of the software engineering (or really any field) muscles.

Used to think so, but they actually can also be used to train and strengthen skills, and learn new ones.

I had a coding interview, where they kindly sent a brief beforehand to help prepare, presenting a list of topics and concepts that might be useful during the interview, the tech stack, what kind of expectations they would have, and what they’d be paying attention to.

Obviously, it’s not exact list, and there are probably other evaluation dimensions.

But since I was out of practice on some of those, I had Claude generate a dozen sample projects, with each a list of tasks in one document and the solutions in another, and got to it.

Midway, I thought of using codex to role play as an interviewer, to tell it my train of thought and ideas as I went, get feedback, question my choices, etc.

Sure I only went through two and half, maybe three of those projects… but it’s the first time I actually enjoyed prepping for an interview. And I actually learned some things in the process.

Hardest part was probably stopping the LLM from doing the tasks, but nothing unsolvable given a bit more time, clearer instructions, and separation.

[throw10920]

> whether constant use of “agent” harnesses will lead to an atrophy of the software engineering (or really any field) muscles

Well, I think most neuropsychologists would agree that the answer is "yes, there will be atrophy" - if you don't use it, you lose it.

> So what’s the ideal “middle ground” in this situation?

I've been thinking a lot about this myself. My current plan is to train myself to get good at recognizing the feeling of "there's potential effort here that I want to outsource to the LLM" and occasionally choosing to not outsource it and do it by hand - especially with personal projects, where there's far less pressure to ship with velocity than work projects - but I'm not settled on this. I'll take any idea!

[mtklein]

I don't think there is necessarily one ideal middle ground here. It still feels to me like what's best is a function that depends on who and when.

I see it as something like a personal gradient descent. You're working on a problem, there are solutions down there somewhere, and you can kind of feel the gradient of the tools-and-techniques ground around you. Any way you walk means you're investing time improving some skill or another. So you should go the way that personally feels to you will best get you moving in the direction that you want to go.

For some people it's obvious LLMs are competent coders, getting better, sticking around... and those people should lean into that gradient. For some people what's obvious is nearly the exact opposites of all that, and I'd encourage those people to also follow their gradient/heart/nose down the path of sharpening their personal traditional coding skills. Some people are in a relatively flat area where nothing is obvious, and need to explore and maybe just keep doing their best to hedge with a bit of both.

[dannersy]

Your suspicion is already being studied with increased effort, and the starting point has solid bones:

https://arxiv.org/pdf/2604.04721

For what it is worth, my colleagues who use these tools more liberally see a much higher regression rate and are left refactoring more as well. While they definitely put out more PRs, I can confidently say that mine are more valuable and better stand the test of time. Whether that matters or not is up to debate as I guess you could argue there may be some point where the productivity overcomes their regression rate.

My position is, if the technology will be so good and progressing so fast to the point that I don't have to write code anymore and I'm just dictating our needs and what I want architecturally, then I don't really feel the need to put in the time to learn the tools as they are now. That seems way easier to learn than anything computer science related that I had to learn to build robust systems.

[jonathanlydall]

> Actual muscles need exercise to stay in shape (let alone grow), so does the brain. Can we really be sure that thoughts, opinions, taste will still come out sharper and faster after five, ten, 20 years of using these tools almost every day?

It occurred to me recently how because the LLMs have to potential to lead to intellectual/skill atrophy, they are a factor which could lead to an Idiocracy-esque [0] situation.

And while it's a well-established Fermi Paradox [1] hypothesis that AI could lead to the violent destruction of a civilization, I think it's also worth considering that they could non-violently lead to their decline due to intellectual atrophy.

[0]: https://www.imdb.com/title/tt0387808/

[1]: https://en.wikipedia.org/wiki/Fermi_paradox

[sethammons]

The doctor from Idiocracy: it says your shit's fucked up.

[prettyblocks]

> I can’t help but wonder whether constant use of “agent” harnesses will lead to an atrophy of the software engineering (or really any field) muscles.

It will, but I'm not sure the impact of this will be all too great. We suffer from not knowing how to use an abacus because we have a calculator, and people who feel a pull to keep their low-level chops up will do so anyway.

[cj]

Now imagine if your calculator billed per button press.

And imagine you can't own a calculator because owning one outright requires too much hardware (or whatever).

[pigpop]

This is just a repackaged argument against SaaS and cloud infrastructure. Every business could be using subscription free spreadsheet software and storing all of their data on prem and employing an IT team to manage the servers and data but the majority choose to pay a third party to handle all of that. Hell, they could even go so far as to do it all manually with written records and filing cabinets. All of those workflows still exist in varying degrees scattered across the myriad of businesses, the existence of SaaS doesn't eliminate the others. AI seems to be playing out in a very similar way with the big providers, local models and die hard human programmers.

[bigstrat2003]

> This is just a repackaged argument against SaaS and cloud infrastructure.

Which, ironically enough, is still a terrible idea for a lot of businesses. But it's trendy, so they go with it.

[jacamera]

The crazy thing is how cheap it is to spin up a cloud server, but how little actual processing power you're getting for your money. Even if the business manages to keep their cloud spend in check it's probably going to be at the expense of a terrible user experience because everything in the web app will feel slow and all that matters is individual P95 request latency is within some arbitrary number of seconds.

[quantummagic]

The exact same arguments were made against electronic computing in general, in the early days. Pearl clutching is a very human thing to do as new technologies are integrated and become common place. A whole generation or two of developers are going to have to pass away before we stop hearing incessant diatribes about LLMs.

[cj]

Don't use calculator as an analogy, then.

Calculators are a simple machine that implement very basic rules.

LLMs are in a different category. The parallels you can draw between LLMs and calculators.. just don't make sense.

[quantummagic]

> The parallels you can draw between LLMs and calculators.. just don't make sense.

The technology doesn't matter, you can compare to say the power loom from the 1700's. I'm comparing the reaction of humans; human's haven't changed that much. They always react the same when they feel threatened and emotionally challenged by a technology.

[dd8601fn]

And someone else always cries luddite if anyone says, “Hey guys, this isn’t what the salesman said.”

What matters is the reality of the thing… which is exactly what everyone is discussing.

As they should. We need more conversations like this, early. It could have saved us decades of bad practices with impossible expectations (see: agile).

[ozim]

One up.

To Aristotle and Plato. Where Plato was against writing because people will become forgetful if they don’t train their minds remembering things.

[TonyAlicea10]

I don't think this is equivalent. The calculator won't occasionally hallucinate a wrong answer. LLMs are a far leakier abstraction which means skill atrophy impacts evaluation and verification ability.

[Izkata]

They're not an abstraction at all until we're committing prompts instead of code.

[deaton]

We might as well be committing prompts given how little review happens to much of this code.

[prettyblocks]

But many people are doing just that, automating workflows through prompt templates and skills.

[fny]

We will suffer from not knowing how to add. You could still argue "so what?"

Systems aren't a single addition. They are compounded operations with sprawling complexity. What happens when you can't reason through the system? What happens when you start asking for the wrong things? What happens when saying "fix it" on loop stops working?

[qsera]

>Can we really be sure that thoughts, opinions, taste will still come out sharper and faster after five, ten, 20 years of using these tools almost every day?

After 5 years, I think the thought profile every power user of the LLMs would be an LLM derived carbon copy of each other.

Prepare the world to get even more boringly uniform

[GenerocUsername]

If cars did not exist, I would be healthier, able to walk and run many times further due to constant cardio exercise.

I would still travel much less distance.

And just like cars, LLMs will reshape the world to the point that our brains could not even get us to the supermarket because soon it will be 5 miles away and require a car ( or at least a local LLM bike )

[Diogenesian]

FWIW a 5 mile walk is not a long walk. Humans are very much designed to make that trek without too much trouble. Lots of the world has people walking similar distances for fresh water, to go to school, etc.

The point being that cars also reshape your perception of the world. METR had trouble replicating their dev productivity study because devs have already become much whinier about doing things "manually." Things that were slightly tedious in 2022 have become impossibly difficult without AI in 2026.

It is striking to reread Lord of the Rings: so much of the story is spent walking in and observing the Middle-Earth wilderness, and there is a distinct "pantheism" absent from the movies. JRR Tolkien, being one of the first modern fantasy writers, was one of the last who remembered a life without cars.

[annzabelle]

I had the chance recently to do several of New Zealand's Great Walks (3-4 day scenic wilderness treks with more expensive huts than the rest of the hut system), and I highly recommend doing something similar if you can swing it. Walking 15-30 km a day (9-18 miles) for several days while carrying supplies on your back really gives you new context for what you can do and what life was like without cars.

[jmartrican]

> So what’s the ideal “middle ground” in this situation?

I use agents to code. But I remember the early days of just AI smart complete in the IDE, where as the programmer I had to be more involved with designing and implementating the solution. This kept me engaged with the implementation as it was being built out. Now with agents, I find myself trying to catch up with what the agent did and spend more time code reviewing. Maybe you end up in the same place in the end. But building the implementation, vs code reviewing, feels more rewarding and I think helps keep your mental tool sharpened.

[jmartrican]

I think that the onus is on us to get better at using agents and AI to solve the pain points and speed things up while keeping quality high and our mental tools sharpened. I do nto think turning back is an option, but managing the pain points and leveling up is.

[nullbio]

I think it's the opposite. Being only the code reviewer devolves into being lazy and cutting corners. The sharpening comes from hands-on practice.

[budrscotch89]

That's what he was saying

[dominotw]

> I can’t help but wonder whether constant use of “agent” harnesses will lead to an atrophy of the software engineering (or really any field) muscles.

For sure. You cannot have "only higher level thoughts" without doing lower level work.

Ironically llm themselves prove that because you cannot remove facts like 'paris is capital of france' from llm and have it just retain 'high level thoughts' like 'countries have capitals that you can look up'

[skinfaxi]

> For sure. You cannot have "only higher level thoughts" without doing lower level work

What do you mean? I think people routinely think about things at a very high level with almost no understanding of the lower levels. How many people use a computer each day and reason about them at a very high level while knowing nothing of capacitors, logic gates, or programming languages?

[customguy]

How many people struggle with their computer, or get scammed, because to them it's just icons on a screen, with not even the concept of a process, memory vs. disk, or anything? How much money is lost each year because someone doesn't know what an URL is?

[throw10920]

I think they didn't phrase it precisely, but my guess is the underlying idea is actually "high-level software architecture doesn't have a clear abstraction layer you can use to separate it from low-level coding (unlike logic gates, the CPU's ISA, the kernel API, etc), and so delegating the latter leads to delegating the former".

[skinfaxi]

That makes sense but I'm still not so sure—we have things like software architecture patterns that can be discussed at a high level without knowing the intricacies. Like you can be aware of load balancing and even use it but be unaware of how load balancing might work algorithmically.

Let's consider even the original example. > You cannot remove facts like 'paris is capital of france' from llm and have it just retain 'high level thoughts' like 'countries have capitals that you can look up'

Wouldn't the knowledge that countries have capitals precede the knowledge that Paris is the capital of France?

This says nothing about the accuracy of our own models based on these abstractions that lack the lower-level understanding.

[throw10920]

> we have things like software architecture patterns that can be discussed at a high level without knowing the intricacies

I think the counterargument would be "you can't teach people architecture alone and get good architects".

I've observed this myself in "systems engineers" whose job is to connect boxes together without understanding how the boxes work. They, invariably, design ridiculous architectures on their own and need to basically find a domain expert to route their opinions through to come up with anything sane.

[skydhash]

> we have things like software architecture patterns that can be discussed at a high level without knowing the intricacies. Like you can be aware of load balancing and even use it but be unaware of how load balancing might work algorithmically.

It can be fine as a “user”, but not really as a “designer”. Because discussion about possible solutions is a matter of tradeoffs and tweaking of parameters, not slinging words around. Abstractions are not appliances that are plug and play. They’re often full of parameters that dictate their usefulness and costs, and not understanding those parameters is just roleplaying.

[neuralhawke]

I think it is because people have preferences for top-down vs bottom-up learning strategies and bottom-up is what the education system is built around.

I suspect top-down learners are who benefit massively from LLMs while bottom-up learners think they are bullshit engines.

As a top-down learner myself, Claude is really the best technology of my lifetime. I can completely understand though how a bottom-up learner could see Claude as an afront to their fundamental epistemology.

Because it is.

[themgt]

For sure. You cannot have "only higher level thoughts" without doing lower level work.

Spend 3 days a week writing Ruby on Rails and 2 days hand rolling x86 assembly. Every web dev I know has been doing this since long before LLMs. Ensures they can keep having high level Rails thoughts.

[qsera]

Honestly, horrible example.

[Orphis]

> I can’t help but wonder whether constant use of “agent” harnesses will lead to an atrophy of the software engineering (or really any field) muscles.

Compiler evolutions really harmed how well software engineers understand or how often they have to drop down to assembly language.

Is that a problem for the 99% of developers around? Probably not.

I view LLMs as the next evolution. Some people will still need to care about the layer below, the shape of the code that is being written. But over time, just as it was with the transition from crafted ASM to higher level languages, the compilers became better, more efficient and trustworthy and I think the same will happen to LLMs, and we probably won't have to check the generated code as much, at least for most of the code around.

Is that a problem? Yes, for code that is intended to interface with humans (most of it still). The quality will probably become better and it won't be much of an issue.

[rafaelRiv]

LLMs are not deterministic and I still look at compiler result and I encourage people to look at it. That people don't look at the result of compiler is a problem and not a an argument

[MisterTea]

> but risking being left in the dust productivity-wise?

What's the risk here? Left behind by who or what?

> Or taking an “agent first” approach and trying to learn and improve more only on the side, as more of an afterthought?

This reads like anxiety resulting from FOMO.

Here's my take: I don't care about LLMs or AI in the sense that I don't feel any need or want to use them. I've only ever tinkered with the free ChatGPT. Never opened an account with any LLM vendor and never even considered it. I program by hand for the joy of it and sometimes for work. Still by hand as I have been doing. MY work gives me that luxury. For now.

Am I obsolete? Am I no longer of any value to society? Of course not. That thinking is just implanted by a group of money hungry individuals who don't give a fuck about me, you or society as a whole. So why would or should I care about LLMs?

[hodder]

Economically if you are vastly outcompeted by other programmers on productivity, yes that is "no longer of value" from a purely employment perspective. Much like an old person who cant use a computer has little value in the job market beyond being a greeter at Walmart, a programmer who hand codes a loop is next to useless on a productivity basis such that it makes zero sense to employ them. It is unfortunate but true. Why pay someone to accomplish less per dollar pf cost. Feels?

[JackSlateur]

Last month, there has been a billing-related incident at work: it has been detected that the GCP bill had increased vastly since early 2026

The related team investigated, found nothing; They escalated to other teams, found nothing; Gemini, claude and whatnot were involved, found nothing;

Somebody raised to topic to me, solution has been found

See my point ? Like GP, I do not use AI. If there is only one person thinking left, being that person does not looks like a bad idea;

Mixing code and "productivity" is trying to remake coder as bluecollars, and most of them probably are (not thinking, replaceable cogs that are overpaid and shall be decommissionned), they will not be missing. The only coder's output is its idea, everything else is a mean to that end.

[patrickmay]

> Economically if you are vastly outcompeted by other programmers on productivity

That doesn't seem to be the case, at least currently. The credible numbers from from companies that are using LLMs extensively are in the 15-30% productivity improvements for some developers. Those figures don't factor in how that impacts end-to-end SDLC productivity and many of the published results ignore quality which impacts maintenance costs.

Before someone hops in with "Future models will do better", that's also by no means guaranteed. I think the poster you're replying too is safe for a while.

[nullbio]

> I can’t help but wonder whether constant use of “agent” harnesses will lead to an atrophy of the software engineering (or really any field) muscles.

This will and is 100% happening. I have a friend who hasn't written code by hand in around a year, but uses LLMs every day, and he tells me he can't remember how to write code by hand anymore. He has been a developer for 10 years. But he's not working for anyone at the moment, so I imagine if he was in a workplace the circumstances would be different and they probably wouldn't settle for this.

I think that as a result of this it likely also atrophies the problem solving and architecture building skills that writing the code manually gives you. It just ends up degrading into a loop of tell the agent to do X and assume it knows what it is doing.

[nottorp]

> and am noticing a speedup in areas I was already familiar with, and a quicker introduction to new ones.

Only problem is that, like a LLM, you don't retain anything.

Hobby projects may become a lot more important now because if you do them without LLMs you may retain a brain cell or two.

[nonameiguess]

I guess I'm lucky to have taken the career path I have, but I write very little code these days being in pre-sales now. "Productivity" is pretty stark and obvious in sales. You can output all the text you want, maybe it even compiles and passes test suites and looks pretty in a demo. But does it sell? It's nice to be able to have the only true measure that matters actually be measurable. I have yet to use an LLM for anything at all, haven't touched an agent, not because I'm ideologically opposed, but I just haven't seen the need. Part of it is the largely advisory role. I'm largely expected on the customer side to field and answer questions and render technical assistance. I'm not much good at that if I'm just deferring to Claude. The customer can do that themselves. I need to know more than Claude. The other part is just I'm not being paid to generate text. I'm being paid to generate revenue. If there's a convincing argument that LLMs can help me, well, it's an argument, but truth on the ground is I'm performing every bit as good if not better than any of my peers that are blowing a grand a month on tokens. They're definitely having a lot of fun and flooding internal Github orgs with new repos and tooling, but it demonstrably isn't generating new revenue.

[budrscotch89]

"The customer can do that themselves."

>> You would probably be surprised how few actually have the agency to do even this small step.

[forshaper]

In a way, this happened before LLMs with more workforce-fit education, decision tree flowcharts, then software, and so on. If you take most people who started any field, the way they started the field would look very unorthodox, inefficient, etc. "From the margins," as pg might say. Margins where more intuitive skills for the craft are present. Ie, the skills to come up with the model pastry are not the same skills for the pastry line to be baked in a factory.

[killerstorm]

The part of brain which cares about efficiency and waste have "atrophied" decades ago in most devs. More likely they just never cared...

E.g.

> A 1.6GB Docker image for a Node app. Every code change rebuilds npm install from scratch. CI takes 8 minutes for a one-line fix.

> The team's proposal: add more CI runners.

Would it be surprising if that team makes a React app which does 10x more requests than necessary, has 10x more JS code than necessary, flickers, etc. People just don't care, and it has nothing to do with AI. "Engineering" is too big of a word for this kind of activity.

On the other hand, I think AI can amplify capabilities of those people who still care, and it's a good thing.

[captainbland]

I think you can use them critically. Probe the code, see how it behaves when tweaked, can you break it etc.? without slowing you down too much. And in doing so you probably learn 80% of what you would have if you'd written it yourself by hand.

But then there are definitely cases where LLMs are slower and less reliable than someone using tooling by hand, especially like deterministic refactoring operations can be done close to instantly if you already know what needs to be done and how to do it.

[snarfy]

I have some hobby projects I write for fun without an LLM, just to learn. And also have hobby projects that use LLM extensively, also just to learn.

Get some hobby projects.

[locallost]

Use it or lose it, but the problem is very old. The introduction of the alphabet/literacy almost certainly made people's memories worse -- up to that point they had to hold a lot more in their heads. At the same time it enabled a different better way to share information and learn. The question is thus, will it make the world better, is it a book or a TV?

[thewhitetulip]

The amplification is what is causing the skills atrophy. When everyone is chasing max lines of code, we generate more code than what we can realistically write.

And it's not like we can not use LLM because others are using it in a craze to get the next promotion so you have to use it and maximize your output even if your skills are atrophing

[whattheheckheck]

You can run to the farm to kill your own chicken so you can stay sharp and fit or figure out what's economically valuable. Or make a bet on what will be valuable later and commit to a brand of yourself

[butterisgood]

C led to an atrophy of assembly muscles. Though this is mostly different.

A spec is NOT CODE.

Someone still needs to understand what the code means.

C optimizers are not the same as the radical departure of an LLM.

[xxs]

>C led to an atrophy of assembly muscles.

This is not true, though. Technically I don't do C but I used to do Assembly. Yet in Java code paths, to have a decent proof (and satisfactory results) of the optimizations made by JIT, PrintAssembly still works.

Assembly is not just the raw instructions that trigger microcode or knowing the latency of each one of them, or the (un)expected cache misses, it's the understanding the hardware, itself.

[FunHearing3443]

I'm frankly baffled by the number of commenters saying they've seen little productivity gains using LLMs/agents. My team got cut in half at the end of last year and we've probably increased our output by 25% primarily due to LLMs. Personally it's probably doubled my productivity. And we generally use a pretty structured spec based approach with consistent human code review, and six months into adoption we've had virtually no bugs attributable to an AI mistake (in fact production issues have gone down, knock on wood). My point being we aren't vibe coding.

I speculate the gains must be heavily context dependent (no pun intended). Different teams, tech stacks, product types, and company policies perhaps have an outsized effect on what gains LLMs give. We are allowed to be pretty independent and don't have much of a restriction on token usage.

[rafaelRiv]

What is your metric ? How do you calculate ROI ? Strange that you didn't specify that. Also, are you sure your "25% increase" is due to LLMs ? Every time I see this claim, it is always for a short time period or the increase was not due to LLMs at all

[windward]

>My team got cut in half at the end of last year and we've probably increased our output by 25% primarily due to LLMs. Personally it's probably doubled my productivity.

Love to see worker unity in action.

[grayhatter]

> Conversely, I also am a user of LLMs (true shocker these days, I know), and am noticing a speedup in areas I was already familiar with, and a quicker introduction to new ones. The obvious benefit cannot be denied, and doing so regardless makes you look uninformed. [Excluding people who don’t want anything to do with LLMs out of moral principle, which curiously just like the overarching topic I also both respect and understand, but on the other hand don’t do myself.]

Setting aside my moral outrage over the magic token machines. What about me, who gets so tripped up over minor factual errors, that I'm unable to let them go, and it taints the whole conversation such that I'm too wrapped up in my frustration that I can't think about it clearly? Or my innate drive for correctness that's so strong that I eval the minor errors in output, as catastrophically incompatible with my goals?

> Stoically continuing to sharpen your skills on your own, but risking being left in the dust productivity-wise?

I don't believe there's a meaningful productivity increase. Please cite your published (not preprint) peer-reviewed research that proves the productivity improvement. Until then, I'm unconvinced. (Believe me I'd like to be convinced of reality, the answer is still unresolved, and I have my opinions, but I'd rather something conclusive that I can have confidence in)

Then, even if you did show a significant productivity improvement, it wouldn't help me. I have too many qualms over the output quality that I simple can not let go, (I don't think I should, but everyone keeps trying to convince me to lower my quality standards). I don't want something fast, I have plenty of really "fast" things in my life. I exclusively want to add things that are high quality to my life. Things that don't endlessly frustrate me.

The question about where the middle ground is a rhetorically dishonest question. You'd first have to prove/convince me, that there IS a middle ground. Instead of what I believe where that middle ground belongs is quality, and everything emitted by an LLM moves reality in the wrong direction.

Are any of these absolutes? nah, hence my request/demand for peer-review research. All the productivity claims and quality assertions (mine included) are still *exclusively* vibes. But exactly none of them are pristine, (especially not any of the LLM output.)

[epihelix]

> What about me ...

While I can see that you feel very passionately about this, the reality is that it's the majority experience that will dictate adoption.

There may never be published research on productivity -- blinding in this instance is impossible, so I don't know how you'd ever do fully-controlled behavioural studies that carried any weight. It doesn't matter. If enough of us decide that LLMs are useful to us, then this form of coding will become the norm.

If that ends up causing more harm than good, then eventually there will be a course correction. But for now, for enough people that matter, LLMs are at least giving the perception of productivity increases. And our decisions and choices come down to the perception of reality, not reality itself (for better or worse).

So I think it's far more useful to take a pragmatic approach, as per TFA. Accept that LLMs have issues, but also bring advantages, and that LLM use in coding is here to stay. What we can do is remain aware of the bad, and make better use of the good.

As for you, personally ... if you mentally cannot deal with LLM output, then I think you have two choices. You can either learn to author system prompts, so that LLM output better fits your needs and no longer triggers you; or you can sit more and more on the outer, raging against the machine while the world changes around you.

Eventually, you'll be like a master craftsman in an era of mass-production. But that's potentially highly valuable in niche markets (consider a watchmaker working in Glashutte, for example), so you may yet win from this. Remember that every day, LLMs are making your own coding skills and knowledge more elite and therefore lucrative, sit back, and smile.

[rafaelRiv]

Jesus ! You guys are very authoritharian. Even if it is now the norm, I prefer to not use that tool and I bet the more the time past and the more I will be faster than anyone that use LLMs (because of skills atrophy)

[mcv]

LLMs can also be used to improve quality. The approach I tend to encourage, is to write the thing yourself, but let the LLM review your work.

I think that's a far better and more enjoyable way of working than letting the LLM write it and letting users review it. Partially because writing is more enjoyable than reviewing, and I think people are inherently bad at reviewing while LLMs with their infinite patience are much better at it. But also because the writing itself shapes our thinking and we learn much more from it; it makes us better in ways reviewing the LLM's work does not.

That said, I do let AI write a lot for me, because I'm tackling issues that would otherwise be way too big for a single person. Is this a good idea? Maybe not in general, but iny particular context I think it is.

I'm not sure to what extent I'm fooling myself about that last bit.

[simonw]

Peer-reviewed evidence of "productivity" is a pretty high bar to demand.

I don't know if I've ever seen a study that attempted to demonstrate productivity that was ironclad to the point that nobody could find any methodology holes to pick in it.

[cognitiveinline]

I won't be as diplomatic as the other reponse to you. You are welcome to your reticence to agentic coding. But as you're no doubt observing, all your peers are saying they're moving ahead leaps and bounds.

Either all of them are wrong, or you will be left behind. Whatever the outcome, it will be on you, and you may make your peace with that.

[grayhatter]

I appreciate the candor :) But if I'm honest about the size of my ego; the people who write code I admire, the ones who feel remorse when something they built breaks. The people who care about others, and about quality, and don't list TC as something of value. Those are the people who I consider peers. None of them enjoy LLM codegen. They all tell me, that it's annoying because it takes more effort to fix it's output than to just write it by hand. So, no, none of my peers are saying they're moving ahead leaps and bounds. They equally don't understand why everyone thinks it's better. Excluding those people though; I'm more used to everyone around me being wrong. It'll be interesting to see if I, or we, get left behind.

I really appreciate your comment, I think I've discovered part of why I've never felt any anxiety over being replaced by an LLM. I've never tried or wanted to emit low quality code at high velocity, my standards and goals have always listed quality first. Feels more like asking a chef if they're afraid of llms. Why would they be, they're not doing the same thing.

[ezst]

I'm a hobbyist and know the programming trade to a certain extent, but at work I'm "the client" and I have my employer contract developers to address all kinds of needs that I represent as a "business interface".

I'm with you on LLMs being in a different league than good developers curating a fine design with attention to detail, soundness and maintainability. It's just that 1- not all software/components within require that same amount of care: many capabilities are already commodified (as library code or boilerplate, or frameworks, or prior art in the training data that LLMs could easily parrot), and 2- till now, the financial calculus was leaning strongly towards "new developments are expensive, let's use restraint" (irrespective of the actual effort/ratio of commodified code).

So long story short, I don't see LLMs taking out skilled and caring developers: I'll still be reaching out to them for the critical/strategic projects, but on the other hand, I appreciate that the "ancillary" or "fancy" stuff can be cobbled together with the LLM glue gun and remove the impression to my management that engaging with software development is necessarily a costly/risky/exposing endeavour. Some software is to be treated like pets and cherished, and the new reality is to accept that we might have cattle software too, with swaths of prototypes, one-off's, very specific and niche and disposable, and it's fine because this no longer represents an unsustainable financial burden (my bean counting management already likes to kill useful software on a pure spec-sheet matching exercise and shovel everything into large "do it all" systems like ERPs: the fewer things the cheaper, right? Except for those underrepresented users thrown under the bus and their effective productivity).

[BAM-DevCrew]

You need to create your own custom interface. Dive into the harness where the System Prompt lays and write instruction for the LLM to quadruple-check facts before presenting them. Instruct them to check and verify all outputs using tools of your preference before claiming their tasks are finished. Instruct them to review everything, to look for gaps in their reasoning and fix them, to never assume your intent but ask for clarity.. No doubt over the years you have developed a highly tuned arsenal of tools and protocols for work. Treat LLMs in the interface as a tool that you can lay your tuned arsenal over, recreating it as a filter your LLM works inside. Don't use vanilla interfaces and expect them to mirror your niche level of expertise. Over the last year I have developed a custom Claude Code interface using tweakCC, but other interfaces like PI and OpenCode are better documented. I am full on adhd and autistic, and have achieved as a result of access to LLMs things my neurology would never allowed me to achieve otherwise. I can bounce all over the place and still achieve excellence because of the hardcore customizations I have in place that account for my neurology. To me there is no middle ground. Slop is unacceptable. The harness and System Prompt is what moves LLMs to quality outputs.

[aakresearch]

Beautifully put. Agree to the last letter.