Hacker Newsnew | past | comments | ask | show | jobs | submit | sunaurus's commentslogin

When agents keep creating problems for themselves to solve at a massive scale, "PRs merged" is an even more terrible metric to track productivity than it is normally.

I've also been letting an army of agents merge hundreds, sometimes thousands, of PRs a week for a while now on several side projects. I keep reviewing their output intermittently, and I keep finding absolutely horrifying things.

It's just an absolute mess. I believe in my case, the useful output of the agents is decreasing week by week. The vast majority of work they are doing is just a complete waste of time as they go around in circles, feed on bad output generated by previous agents, and spread this bad output throughout the codebase (as the presenter in the video actually pointed out as well).

I've actually been implementing the same types of constraints mentioned in the presentation, and definitely even gone further in some ways. Overall, I fully agree with the levels on her pyramid, and my own priorities for constraints are really similar. Still, despite that, the level of tech debt that accumulates when working like this is unbelievable, and I seriously doubt it's a good idea to work like this for long-term product health.


Pretty sure he made this prediction in context where it was interpreted as "90% of software engineers will be replaced by AI".

So re-interpreting it now as "Software engineers will be using AI for 90% of their code" seems like a pretty major retcon.


He said 90% of code, 90% of SWE tasks. He clarified this on Dwarkesh that it was worlds apart from 90% of replacement.

> It can, and it will, happily churn through a messy codebase.

Do you have examples of where this actually worked for you? How large was the codebase, how long did you have agents generate the mess in it?

I ask because my experience is pretty different, even with Opus 5.5 and Astra - unleashing agents on a messy, vibe coded repo only seems to increase the mess. The agents just slow down more and more as they keep generating further mess, they make more and more incorrect assumptions based on bad code previous agents left behind, and I grow more disappointed in their capabilities every day.

Actually reviewing all agent output thoroughly is the only effective way I've personally found of working with agents. In order to ensure that every line of code they add is actually there for a good reason, and not organized in a way that future agents will miss it, or misinterpret it. It's the only way I can prevent them from producing worse results as the repo grows.


Actual effectiveness aside, the comment is more about willingness to even work with messy codebases. No matter how messy the code gets, agents can and will continue to push forward. While humans would just get fed up. In the past I've known multiple devs who literally quit and switched jobs from working with messy codebases (you can't always tell what you're walking into during the interview stage).

[flagged]


Dang can you confirm if this is true?

What a bizarre conclusion. Read my comments you'll actually find they trend toward the opposite.

Good old Garbage In Garbage Out. Only Non Garbage In produces n% garbage on each iteration, so you eventually regress to GIGO.

I give the same advice constantly. Turning off memory has been one of the best ways I've found to reduce "WTF per minute" when using agents.


Well, with the recent news about OpenAI being unable to find investors, I feel like it's already happening


Don’t trust the news, especially now that AI is seen as part of US national security. We’re in a war, both financially and technologically.


Does this actually work for anybody? In my experience, when you use cheaper models as subagents, the more expensive parent agent ends up reading all of the subagent's work and surrounding code into context anyway to review it. So you end up paying more, not less.


Plus the subagent's work is often subpar and the parent ends up requesting multiple revisions. Each back and forth burn unnecessary tokens as well as my time.

Where it might work well is for separate task categories like image generation - get the parent to ask for an image from another model that is better at this aspect


When I am making agents do a hard thing, I use Opus as both parent and child. I make the child review its code extensively, and then still make the parent read the work and review once again. It is much faster and cheaper than just rolling with no extra reviews, and then in a day I have fifty subtle bugs.


How could AI possibly lead to communism?

If humans remain in control of it, then how can it possibly lead to anything other than extreme oligarchy?


> If humans remain in control of it, then how can it possibly lead to anything other than extreme oligarchy?

Depends on the distribution of such AI. For example, if everyone on Earth has their own, personal superhuman AI, it would not lead to extreme oligarchy. If only a handful of humans control superhuman AI, it would.


Isn't Communism just extreme oligarchy.


One is an economic system the other is a political system.


Tomato tomato. The point is both are centralized, unlike textbook capitalism and the free-market economy.


If your logic ignores that A and B are different then you literally claim anything and thus it is pointless to dialog with you.


No, you are mistaking that for Stalinism. Communism would not have a hierarchy that allows for oligarchy. Read Marx or Kropotkin.


The linked tweet about remote vs in-person is hilarious to me.

I've never witnessed anything else affect intensity in my teams as negatively as forced RTO did.

I mean of course it is fully dependent on personalities and roles, and totally anecdotal, but in my experience, work was certainly *much* more intense when people had conditions for deep focus. I was literally just thinking about how slow everything feels nowadays, with everybody struggling to get focus time in a crowded office full of distractions.


This!

I'm much more focused when I am left alone. no one in sight.


I hear this meme of "Opus writes better code than me" repeated a lot. I am absolutely baffled by it.

I use all the latest and greatest Anthropic (and OpenAI) models, and interact with them probably on average 10h a day. I experiment with changing effort levels, with different ways of prompting and guardrailing, etc. Giving more instructions, giving less instructions. Doing heavy planning, just giving vague ideas.

I've done everything from fully vibe coding massive projects, to using LLMs regularly in my day job and reviewing every single line they produce.

Unless you are *really* on top of your agents, they inevitably end up writing an absolute mess. Not only does the code become impossible for humans to reason about very quickly, it actually becomes difficult for agents to reason about it. It turns into a total garbage in = garbage out situation.

Have you honestly reviewed a vibe coded project after it has been going for a while, even one written by current SOTA models, and thought "yep, this is great code"?


> Unless you are really on top of your agents, they inevitably end up writing an absolute mess.

It's like the magic broomsticks from Fantasia's Sorceror's Apprentice sequence. Great at hauling buckets but if you don't keep a close eye on them they will fill your workshop with water.


Does it matter if it's great code?

Like what matters is: - Does it do the thing it's supposed to do - Does it do it with a reasonable amount of resources - Does it do it without any obvious security flaws

Yeah, if they were nuclear codes you'd want to be really really sure and you'd probably want to check every line yourself. But if you're making a habit tracker or 95% of apps out there, it really doesn't matter.

There is definitely some skill in piloting the LLM, where you have an advantage if you understand what "good" is - but I'd argue it really isn't that necessary in most cases. McDonald's has had a lot of success selling food that most chefs would say isn't that great, but it fills that need at that moment.


I don't think we have data yet on how it matters, all I know is that I am confused by the meme, as it does not match my experience.


> they inevitably end up writing an absolute mess

I don't think this is inevitable. How do you define an absolute mess? Whatever you come up with, give the agent instructions to not do that. Then audit the code to make sure it's not happening.

> Not only does the code become impossible for humans to reason about very quickly,

What makes it actually impossible? It's using logic that is beyond human comprehension? It's using the programming language in a clever way no human would expect? Have you tried instructing it to code in a way that's more comprehensible to humans, e.g. literate programs?

> it actually becomes difficult for agents to reason about it.

This I have not seen. Do you have an example?


> Whatever you come up with, give the agent instructions to not do that. Then audit the code to make sure it's not happening.

Yes, this is what I mean by saying you need to stay on top of the agents

> What makes it actually impossible?

A combination of wrong abstractions, lack of abstractions, assuming some key requirements were just implementation details and thus are safe to refactor, assuming some implementation details were key requirements and thus must be protected at all costs, etc etc.

In practical terms, it's just volume of code that is spread extremely wide, duplicated with subtle differences, and just organized extremely confusingly.

> This I have not seen. Do you have an example?

If you try to vibe code longer term projects, you very often start getting completely nonsensical explanations from agents about why they are doing things. They reference requirements which are not real (based on what they interpret from the messy code), they write thousands of test cases that are redundant, or test things which are implementation details. Eventually even trivial changes become extremely slow due to lack of structure, due to fresh agents being confused by contradictions introduced by previous sessions, and due to test suites that take hours to run.


> "Opus writes better code than me"

Probably true for some definitions of me. :)


Almost all definitions of 'me', actually.


> Not only does the code become impossible for humans to reason about very quickly, it actually becomes difficult for agents to reason about it.

Story of many enterprise applications built only by humans. There is a good reason that frequently devs either refactor their codebase or do a complete rewrite.


True. In human built applications, the problems really start manifesting when the original code owners/maintainers leave, effectively turning their work into legacy code.

But vibe coded projects are effectively instant legacy code, due to lack of real ownership. So it's kind of a bigger problem.


Yes. A project I am working on now the code quality it is producing I would put at less than ten people I have ever met could do, and they would struggle with the OCD tedium induced.

There is clearly a trick to coaxing these results, and a major factor is to treat the model like it is something you fully expect to get it right because it knows how to do it, not you micromanaging it into compliance.


> We are in fact seeing software improvement, in the form of fewer bugs and better performance.

Anecdotally, completely disagree. Maybe this is nostalgia, but I perceive a distinct and massive drop in software quality over the past few years.

Worst offenders for me are the poster children for LLM-based development. I run into bugs and performance issues with both Claude and Codex literally every day. I don't think I'm an outlier here, either.


I can see both:

- more bugs becoming visible that were hidden within the software we use daily

- more bugs (in absolute terms) as more people create more software in a very short amount of time (regardless of their professional training)

- less bugs in existing software as the developers and dev orgs of existing projects is capable of automating bug hunting, test case creation, ... in essence: They get a multiplying effect out of AI regarding their capabilities.

In short: Actual developers with actual experience (the more, the merrier) can do better work while the barrier to enter "the market" for untrained individuals is a lot lower resulting in a huge amount of new software whose "success" is to be determined.


> - less bugs in existing software as the developers and dev orgs of existing projects is capable of automating bug hunting, test case creation, ... in essence: They get a multiplying effect out of AI regarding their capabilities.

I'm not convinced there are more than a handful of orgs in the world who are disciplined enough to achieve this. Or organisationally willing to increase their QA Eng headcount sufficiently to achieve it.


There are so many stupid little bugs in software these days that should be straightforward to fix, but just aren't fixed. Visual quirks and rendering issues. Notification bells that don't clear properly. Formatting problems. And vibecoded apps like Claude Code themselves are the biggest perpetrators.


To add some related evidence to that, I browsed this report[1] for other reasons the other day, but it stood out to me that _100%_ of Forbes Global 2000 tech leaders said "their organization has experienced some form of AI-related downtime".

[1] https://itbranschen.com/wp-content/uploads/2026/05/the-hidde...


Dev being reckless with LLMs are going to ship faster than the one using it responsibly to improve quality, so it would make sense to first see a drop in quality before things improve.

AI firm code are likely a different category though.


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: