How does normal programmer handles the extreme efficiency of AI? (ai brain fry)

As a programmer for more than 20 years, nearing 30, I use ai, but no automatic coding agents.

I put the code snippets I want into the chat, and think about solutions, and steer the ai to the perceived solution.

If I don't know the solution or cause I use it to "rubber duck" and help me diagnose a lot of things, but often it's just plain wrong, makes wild guesses on outdated, obsolete or deprecated use cases because its training data spans back that wide back(if you're using an well known framework that's been around for a long time and has many breaking changes).

I have collegues that have coding agents, and they regularly run into issues that functionalitty was removed and replaced with something else.

Having to double check every change an ai wants to make gets tiresome and boring, so the human brain goes "fire and forget, next issue" and someone else can try to fix the missing features, spend time finding out what exactly was removed, why, what was changed etc.... costing more time eventually than was saved.

Also asking collegues why was this changed, they shrug, don't know, ai did. Which sucks because knowledge of the software goes lost, and debugging gets slower because it's now "always a new framework" feeling with the mindlessly accepted code parts, with no option to ask a collegue what the logic behind it was, or why a thing was done as it was done.

That's why I limit myself to scoped problems, and I try to understand it, because it saves me time later, and I don't lose my domain knowledge. I just use ai for the boring work.

Mu

the extreme efficiency boost from AI

There is no "extreme efficiency boost from AI". AI can help you write some code more quickly, but some of the time "saved" must be spent to read & understand the AI code and verify that it actually does what you need it to do. It may give you some boost in some circumstances, but you won't shrink 30 minute tasks into 1 minute without receiving the bill (in the form of bugs and unmaintainable code) later.

If you meant "how experienced/normal programmers handle AI tools in general" I my answer would be "with extreme caution if they are wise, with painful regrets if they are foolish, or not at all if they feel they are not sufficiently the former and wish to avoid being the latter"

Your brain barely needs to focus on it before you move on to the next layer

Well, there's the problem right there.

Don't blindly accept whatever slop AI throws at you without taking the time to understand it and find the bugs buried within.

If you want to be a mediocre or worse "vibe coder" who leaves a trail of crap code behind as you move from job to job as everyone gets tired of cleaning up behind you, that's on you. But you'll never get a reputation as someone who can be trusted to write good code.

And when it comes time for promotions and bonuses, guess whose name is not on the list.

But come layoff time, guess whose name IS on the list...

I don't use LLMs in my work as of May 2026. I do not believe that generating many lines we don't understand is particularly useful. We need to carefully read and debug them to avoid serious problems. And it's by definition a more superficial work than inventing and implementing a solution. Hence sloppy work gets accepted and maybe one slop is not that serious when the other code parts are robust, however, when we get tons of slop and they need to interact with each other, then we face the slopmageddon. Hence, in my view is way smarter to take our time, figure out the solution, implement it.

Pros:

• we are comfortable being responsible for code we have written
• we understand the ideas and context, an undervalued feat that we can reuse later
• we train ourselves. Even the "boring work" is training us. Once we stop doing a part of the work and delegate the cognitive endeavor to something else, we start losing abilities
• we are able to explain the code
• we don't need to worry about every single line, because we know that it's not below a certain level
• we minimize the code necessary for a solution, leading to robustness, maintainability, understandability

Cons:

• we write less code lines
• we don't waste company money and hence we are not getting to the leaderboard
• we take our time

Careful work needs time. We can quicken the pace, but then the work is less careful. It's up to the dev to decide whether this seems to be ethical for him/her.

It probably varies from person-to-person, but I feel that pre-AI-boom there was a nice rhythm that was easy to maintain. You would think through a problem, ideate, come up with a solution, then implement/test. The thought processes going into the first half are different than the last half. We can now automate much of that last half, which means you're burning that first half of your thinking a lot more.

Take a break. Drink water. Touch grass. You are not a computer. You need to care for your human self so that it can be creative and ideate again, and also so that you're sharp when it comes to reviewing the work of others (i.e. the AI). It's very easy to look at fantastic results and gloss over key parts that may make or break the whole thing in surprising ways. (The AI makes "mistakes" in different ways than human, and sometimes they're hard to catch.) Fuel yourself so you can remain vigilant. Slow is fast, turtles all the way down, yadda yadda.

I just remain calm, skeptical, and meticulous. Try to avoid too big chunks of code at once. That helps me maintain absolute control over the pace.

I too am facing this problem. I have taken a few steps to improve the efficiency of the code AI writes.

1. I do not let AI take full control over any of the stories I am working on. Whenever I run a prompt to build something, I carefully refine the context.

2. One approach I follow is that for every story/Jira/task I start, I ensure that I define the scope of the story or feature in an MD file, and I attach it as a context file for the prompt. I make sure it is written very tightly and strongly to avoid any unnecessary boilerplate code.

3. Another approach I implement is to think through the solution myself. Sometimes I add comments in the files that would need changes or enhancements to implement the new feature or to build something on a legacy codebase, so that I do not make the codebase bulkier with boilerplate code.

4. I also think that we have become more like reviewers than programmers. However, I am sure that with the increasing cost of AI agents, we might go back to how things were a few months ago, with more manual effort involved. For now, I do everything step by step so that I have time to analyse everything line by line and add comments to fix issues where needed.

5. Also, I am a bit tired of how many unnecessary tests it generates. Some of them are useful, but they still require careful review and filtering.

   Just some inputs on how I tackle the heftiness of using programming agents.

If the system is moving faster than you are that’s a PEBKAC—use the AI to help your brain, not just code. Nutshell: The dev field already moved faster than people could keep up—no different now, it’s up to you to decide how to think, and what precisely to spend your thinks on.

Good programmers will start using AI and become better. Poor programmers will try to look like good programmers with AI and fail when the task is not known for AI and it cannot help.

The stackoverflow's recent blog on this kind of topic might be of interest to you: see https://stackoverflow.blog/2026/05/22/dispatches-from-o-reilly-the-accidental-orchestrator/?cb=1

I think you have understood my question correctly and i thought similar.

Regarding the AI slop - I am thinking past this - e.g. I feed 2 controllers into claude as an example and i ask it to produce the same for another model - and I have witnessed multiple instances, where it generated perfect (complex) code like this - not a single error/issue was there (because it exactly copied the style from the previous ones).

At present, yeah, AI might be making mistakes, but again - I noticed som instances where for example claude did produce perfect code (perfect = meaning exactly as per the company standards)