> steer Claude away from over-engineering parts of the system in response to hypothetical concerns.
This is my biggest problem with opus 5.5.
It's absolutely incredible in many ways, but it has no sense of "good enough".
It will go around in circles polishing something so to resolve edge-cases on edge-cases.
"Someone could create a class that calls your public method in such a way, that under 3 other race-condition properties, there might be stale data read".
It has no sense that it isn't appropriate to add a half dozen classes just to close that kind of hole, especially when there isn't even such a caller or possible conditions at present.
One thing to keep in mind though is that "someone calls your public method" more often could be an agent, and that agent will try to explore the edge cases.
My problem isn't that it can identify such conditions, the record on cybersecurity lately shows these things are quite good at finding real faults. But the annoyance is that they always want to fix it by adding more things that open cracks. It's possible, sort of, to drive it to fix by removing things instead but it's a battle.
I'm not claiming that anyone is doing this on purpose, but overly engineered codebases are a good thing for a company like Anthropic. If your code is so bloated that it is pretty much unreadable without an LLM they win on both sides.
This also sounds a bit like an underspecified interface. If the class spec clearly states under which conditions it is thread safe then the agent can take that into account, but if it doesn't then the agent has to assume that it should guarantee thread safety in all contexts.
Some of this stems from the idea that everything can be reduced to logic, so as long as we solve for all logical states, the end result will be perfect.
Of course, the second you start interacting with the real world and with humans, that doesn't really apply anymore and you have to get to 'good enough' much earlier than a generator would be able to predict.
Even if you steer a model to a very specific goal with an easy to validate end state, it will do things that within the scope and context of the goal a human would not really do. In theory if you put the context of the entirety of a human into a model, you might be able to get much closer, but we don't even have enough power generation on the planet to process that (unless someone has a secret ten orders of magnitude more efficient way of doing that).
Yeah, I had this issue with Claude since the v5, it’s a real pain to get the model to not create its own goals and spend all its time on it. Switching to Deepseek 4.1 flash is so refreshing, it does what I ask for, mostly, even if things take more time and guidance. At least I don't feel I’m wasting all that processing on stuff I do not care about
Perhaps their latest models have ushered in an era of exponentially increasing productivity.
Perhaps they've lost control of their process.
If they've lost control, the system will reach an ugly complexity steady-state of sorts, where any change to improve things will, on average, result the same amount of regression. You'd have to hope the next, new, more capable model would be able wind things back (and not just let you raise the level of complexity, which really just leaves you in an even deeper mess.
To my mind, taming exponential phenomena is hard to do, and requires very careful planning and preparation. I don't see evidence of that here. So my bet is this is an out-of-control mess.
But it will be interesting to find out. (And I think we will find out -- I think it's already too big that they could hide it if it's blowing up or collapses.)
I'm more curious about Antique. Code review is my bottleneck, this meatbag here can't keep up with the agents at all. I either spend too much time and energy on trying to understand the code (not just in terms of review, but to maintain my mental model of the codebase), or just give up and hope for the best.
The over-engineering is definitely a concern too. It's not that how Fable/Opus architect code is bad, far from it, but the projects I'm working with are not always at a scale where it matters as much, and simpler more readable abstractions might be a better trade-off.
I think the point stands: does it seem like they are increasing operating excellence at 5x-10x the rate they were in January? Or is the volume supporting having agents do the same work in 5-10 the commits that a human + agent was doing in 1 commit in January? There is some interesting data people pulled by comparing weekday to weekend contributions in the chart (much of the increase seems to be in the baseline rate).
I’m all for being snarky about those companies but without seeing their commit history there is no way to know if it is a signal you can use to derive anything meaningful
That, and more commits means more data they can clean and train on, whether they're good or not. I'm sure they are commit-maxing and using AI as much as possible since they own that data and can use it however they want.
They believe that the lower cost of code means we should be much more willing than we used to be to accept code and then say "oh never mind it's bad" a week later. I'm not 100% sure I agree but it's a reasonable position.
I mean, at least they dogfood their own product at scale. Even if the result is likely fairly messy, in their position I think I would do something similar. That doesn’t mean everybody should replicate their approach
Do this exercise: Take your company's market cap and divide it by the total number of lines of code in the company's repo. You'll discover that don't need that much code to create value. For Google (somewhat publicly somewhat known), this is something like $2000 per line of code. Your company is probably not too different, certainly within an order of magnitude.
So let's assume 1 line of correct code is approximately 10 tokens and $1000 of value. If you could theoretically write the correct code, $10 per 1M output tokens should get you $100K worth of value, or 10000x return! Obviously, thought experiment, very theoretical limit no one can achieve, doesn't include thinking tokens, etc, but it's worth thinking about how much your code is actually moving the needle.
Maybe I'm doing things wrong, but I don't need that much code and I don't spend that much time producing code (maybe 1000 lines in a productive day), because the bulk of my time is spent researching, testing, evaluating, thinking, etc to find out how to write only very valuable code. 1000 lines is laughable compared to what tokenmaxxers do, but over the course of a month that's a 200-300K codebase and anyone who has worked on something of that size knows it can support a sizeable business.
He basically rebranded himself as an AI commentator/journalist following the playbook of people like Scoble over the last couple of years. I assume his previous endeavors paid off well enough to grant him the freedom to do as he pleases. People (and algorithms) like this type of content so it's well received.
People upvote, the link goes up. The HN front page has never been based on new insights or something similar, it’s just a reflection of what the audience vote for. In this case it’s likely because people here like simonw, who is a known high quality contributor
It's almost impossible to avoid over-engineering these days. I can't make other people generate minimalist code. Before AI, you could reach alignment with your team members and produce high quality, minimal code, but nowadays I find it impossible because:
- People believe they will be able to maintain code just as easily as they can generate it and it's hard to explain the asymmetry to people who haven't experienced it themselves.
- People don't feel like coding is a craft anymore so they don't care about how the code looks. They just want it to appear like it's working and don't care about anything else. As a team leader, you can't get people to overcome this deep sense of apathy they feel towards the code.
This is my biggest problem with opus 5.5.
It's absolutely incredible in many ways, but it has no sense of "good enough".
It will go around in circles polishing something so to resolve edge-cases on edge-cases.
"Someone could create a class that calls your public method in such a way, that under 3 other race-condition properties, there might be stale data read".
It has no sense that it isn't appropriate to add a half dozen classes just to close that kind of hole, especially when there isn't even such a caller or possible conditions at present.
silly as it sounds but its often much faster for me to skim the code and understand it then to read it's summary of the code
Of course, the second you start interacting with the real world and with humans, that doesn't really apply anymore and you have to get to 'good enough' much earlier than a generator would be able to predict.
Even if you steer a model to a very specific goal with an easy to validate end state, it will do things that within the scope and context of the goal a human would not really do. In theory if you put the context of the entirety of a human into a model, you might be able to get much closer, but we don't even have enough power generation on the planet to process that (unless someone has a secret ten orders of magnitude more efficient way of doing that).
100%
And I have a nasty idea that it is by design. "Use me, use me more!"
Perhaps their latest models have ushered in an era of exponentially increasing productivity.
Perhaps they've lost control of their process.
If they've lost control, the system will reach an ugly complexity steady-state of sorts, where any change to improve things will, on average, result the same amount of regression. You'd have to hope the next, new, more capable model would be able wind things back (and not just let you raise the level of complexity, which really just leaves you in an even deeper mess.
To my mind, taming exponential phenomena is hard to do, and requires very careful planning and preparation. I don't see evidence of that here. So my bet is this is an out-of-control mess.
But it will be interesting to find out. (And I think we will find out -- I think it's already too big that they could hide it if it's blowing up or collapses.)
The over-engineering is definitely a concern too. It's not that how Fable/Opus architect code is bad, far from it, but the projects I'm working with are not always at a scale where it matters as much, and simpler more readable abstractions might be a better trade-off.
Maybe it's all capacity, but I've certainly seen an improvement in uptime.
If a module lifespan before it's replaced/refactored is less than a week, then it wasn't a good module to begin with.
This is just hiding all the spaghetti mees that they must have in the back
So let's assume 1 line of correct code is approximately 10 tokens and $1000 of value. If you could theoretically write the correct code, $10 per 1M output tokens should get you $100K worth of value, or 10000x return! Obviously, thought experiment, very theoretical limit no one can achieve, doesn't include thinking tokens, etc, but it's worth thinking about how much your code is actually moving the needle.
Maybe I'm doing things wrong, but I don't need that much code and I don't spend that much time producing code (maybe 1000 lines in a productive day), because the bulk of my time is spent researching, testing, evaluating, thinking, etc to find out how to write only very valuable code. 1000 lines is laughable compared to what tokenmaxxers do, but over the course of a month that's a 200-300K codebase and anyone who has worked on something of that size knows it can support a sizeable business.
- People believe they will be able to maintain code just as easily as they can generate it and it's hard to explain the asymmetry to people who haven't experienced it themselves.
- People don't feel like coding is a craft anymore so they don't care about how the code looks. They just want it to appear like it's working and don't care about anything else. As a team leader, you can't get people to overcome this deep sense of apathy they feel towards the code.
Redesigning source control at Anthropic
https://news.ycombinator.com/item?id=50073633