this post was submitted on 22 Aug 2026
604 points (97.5% liked)
Technology
87649 readers
3502 users here now
This is a most excellent place for technology news and articles.
Our Rules
- Follow the lemmy.world rules.
- Only tech related news or articles.
- Be excellent to each other!
- Mod approved content bots can post up to 10 articles per day.
- Threads asking for personal tech support may be deleted.
- Politics threads may be removed.
- No memes allowed as posts, OK to post as comments.
- Only approved bots from the list below, this includes using AI responses and summaries. To ask if your bot can be added please contact a mod.
- Check for duplicates before posting, duplicates may be removed
- Accounts 7 days and younger will have their posts automatically removed.
Approved Bots
founded 3 years ago
MODERATORS
you are viewing a single comment's thread
view the rest of the comments
view the rest of the comments
I can kind of relate. There are a lot of parts of coding I find a little boring.
When you use an expensive AI agent, like Claude, it can nowadays handle these tasks competently, to the point where I only need to correct small things here and there.
When you give these tasks to an AI agent, it feels a bit like delegating to a junior, but without the guilt of giving someone a menial or boring task. That allows me to work on stuff I find more interesting. To me, THAT'S why it's adictive.
However, this isn't without cost. First, there's the societal costs: Environmental, centralization of power, contribution to hardware shortages and a bubble
Second, there are more personal costs. You'll come to rely more and more on these tools, and your skills will rust. You may end up avoiding learning things about a codebase because you delegate it away.
It's a tempting tool. One which in my experience can genuinely help, but is easy to misuse.
Wow this is all so true and well put.
Some colleagues are showing off 20k+ line change commits with no review. Whilst I'm at most doing 100 lines, usually 10 or less. I am reading each change. Every plan is read thoroughly with multiple iterations. If I don't understand a part, I ask the AI to explain. It is surprisingly good at explaining the work. However I do find mistakes. I have it commit after every change after the tests work and I'd say a third of the commits are prefixed as "fix: ". I'm still on the fence about the whole thing but it feels good and weird and phoney at the same time.
I feel like: we've been developing these "best practices" of documented traceable requirements and design specs, repository storage of the whole change history, trace matrices showing test coverage / validation of all requirements and specs, code reviews, etc. etc. etc. and... for the most part... if you've got exclusively good responsible programmers on your team, most of that is a waste of time. But, when you have personnel turnover, people with ... marginal skills, etc. those practices become much more important, even if they more than qunintuple the time required to do a thing, they enable projects to grow and be maintainable at much larger scale than if you don't do them.
And along comes LLM agents, who strongly resemble those fresh hire colleagues of marginal skills, and they don't complain about these "best practices" wasting time, and they're so wicked fast that they can cut through the process that used to take 500% as long in 20% of the time instead... No, they're not the greatest at getting things right on the first try, but they have been getting good at catching and correcting their own mistakes. And I can type messages like this one while they work on things that don't need my attention...
Our primary use of the Cursor LLM agent is: code review. Refinement of the review to clear out the misconceptions - improvement of the pull request documentation to make intent more clear for everyone - not just the LLM agents.
We also have come (lately) to rely on it for writing unit tests. A year ago the LLM written tests tended to be ineffective, just "whitewash" coverage that didn't really check the important aspects of the requirements. Today, they're probably better than our Sr Sw Eng written unit tests, and you can crank the coverage arbitrarily high with very little effort.
One of my big criticisms of the .NET toolchain is that even simple changes can touch 47+ files, thousands of lines of code, and take hours just to have eyes on everything that changed, whereas a similar change in my Qt/C++ might be one line, or up to a dozen here a dozen there in maybe 6 files, but never the mess I've been seeing come out of .NET/WPF and friends for the past 20 years.