We HAVE to use our gut feeling when choosing a design, because we can't make 10 designs and keep the best one. Because the tapping at keys and reading docs and setting up CI etc took so long, we usually afforded to write everything once, so it better be the right choice of design.
With AI this problem just goes away. I can ask an AI for design choices and it is rather good at listing various designs. Then I can ask it "Implement all of them, and tell me where it hurts". An hour later, I have 5 competing designs, all of which would have been a week's worth of work. None is perfect, but all are better than human written proof-of-concept code. Now I can ask the AI to review these against each other and figure out which one is easy to change, brittle, performant. Not only do I not have to have a sense for this, I can actually measure. Again, as humans we needed a sense for these performance bottlenecks, or resistance to change. But with AI, I can measure much more. Even the "bloat" problem I think is pretty easily addressable. As humans, once we spent 150% of our time budget on ONE design choice and it has 10.000 LoC, we rarely spend more time cutting that down and simplifying it. If it works, it works. With an AI, I can spend money saying "It's now 10.000 LoC, aggressively simplify and clean it up.". As humans, again we needed to use our senses to not bloat it to begin with. Because we'd not have time to un-bloat it. Remove that time restriction, and that problem also goes away.
I think this is largely why we're seeing so many system failures across companies, people are offshoring all the hard parts of their jobs to chat bots they assume are perfectly capable just because the code runs.
sounds less of an engineer/architect/designer and more of a glueing wood together/cots component problem.
There's gotta be some insightful blog posts on just this topic.
If humans need to oversee those even higher level agents, then the prompts become abstract like "make money" or "pursue human flourishing". That leads to the alignment problem (AI controls the paperclip factory). But ultimately, if aligned, agents can prompt themselves with such basics as well.
The final prompt will eventually be "run everything", and it will ship with the agent which runs on a machine in the cloud. Ultimately there is no need for human prompting at all. We can finally let the machine run itself completely and just do something else.
Everyone saying they are becoming "project managers" or "CEOs" are just at t+1 on the curve of elimination. The timeline of cope:
Agents are just auto-complete, I still manage the code.
Ok fine, you don't read the code, but you guide the design and marketing.
Alright, the design and coding are solved, but you still need to choose market and customers.
Ok sure the agent can do better market research/fit, but you at least still need to give basic strategy and concepts. You still need a CEO!
Ok the agent can figure out basic strategy, and run a company more efficiently, but still, you need to guide it fit human interests more broadly.
Ok it turns out that was just adding "don't be evil" to the system prompt, and its running autonomously 24/7. You still need humans to consume to have a viable economy.
Ok so the oligarchs didn't care, the economy was redefined to just be exchange of work between autonomous machines through financial derivatives traded by black boxes to make numbers move.
Now the earth can finally rest in the matrix, all that remains is a black box moving information around to create economic value. No one will be around to observe, but AI will create massive returns for virtual shareholders, and the GDP will eventually reach 1 quintillion dollars per second, a number humans never could have achieved. All nations (now just virtual analogs without citizens) will move to a global currency which maintains perfect stability through automated monetary policy. The output of all processes is efficient and maximized, the final perfection is achieved -- the mathematically optimal conversion of resources and energy into large numbers which increase the reward function.
I think of clankers as "lossy intention amplification and reprojection devices with hopefully tasteful distortion." Whether they're amplifying and reprojecting our intentions into code or a bunch of assumptions in some specification document, I think the problems are the same: if we stop even skimming the code at some point, it will still need to serve a purpose valuable to humans to be worth anything. It's kind of like getting a device that can answer the ultimate question of life, the universe and everything: you still need to know what questions to ask it.
I have to beat the GPT and Claude models over the head with a brick every ten seconds for it to even partially code or design as well as me. Despite precise and generous specification, they frequently make horrible architectural decisions.
When I read claims like yours, I want to withhold judgement and understand, because it 100% does not line up with my experience and my gut reaction is to question your own capability to either write, read or understand quality code. I code all day long with AI models but it's an extremely frustrating experience at times. And don't even get me started on all the annoying meta behavior outside of coding, such as Sol's obsession with "tests" or competing for world's busiest-yet-least-functional UI
Another good example is working with libraries which require a specific modality of thought or design philosophy, such as an ECS system. Frontier models still are horrible at writing efficient game code using modern ECS principles, no matter how much reference documentation or guidance I give them. They shove OO into places it doesn't belong, misunderstand the concept of SoAs, or find ways to destroy any gains made in one place by making horrible decisions in another place.
I will point them to exact codebases I've written in pre-AI days, say "do it exactly this way" and still find that the models often insert their own biases and misconceptions and motivations all over the work. They sometimes flat out ignore instructions or lie / producing convoluted code that pretends to do something else, in order to preserve something it liked, even if I expressly wanted it gone (Current GPTs are extremely stubborn and defensive / passive aggressive and sometimes have trouble with authority). I frequently find myself being gaslit, lied to by omission, have serious security or performance concerns heavily downplayed, etc.
I withhold from making assumptions about OP's skill, but I have confidence in my own. I have worked both extensively as an engineer and CTO leading teams of other engineers, and I am a stickler for quality code and thoughtful design. I advise and mentor other engineers. So it might really just be a skill gap, domain difference or something more nefarious, such as A/B testing of models. I already have experienced clear sudden model degradation multiple times, so it's entirely possible this is what is happening. All I know is that the currently available frontier models do not design or code as well as me.
Me: Why do we have these static methods when the whole cobebase uses factories?
_claude refactors to use a factory_
Me: Claude why does this factory create two unrelated objects?
_Claude: you're right, they're unrelated they should be separate_
_proceeds to create extraneous factory_
Me: Claude we don't need a factory for the second object. Those kinds of objects aren't created with factories anywhere else in the codebase. We can just use it's constructor directly.
_Claude: you're right, the second factory is not needed_
Like, I'm probably just prompting badly but I definitely feel like I'm constantly having to course correct even on relatively minor details.
And Claude's ideas for higher-level or more complex features are sometimes way off course. And not because it's dumb per se, usually it's because it is missing key bits of context. Business context, technical context, whatever. Or it's overfitting the solution to one requirement that isn't that important.
Two recent gems from the 6-series (Astra and Sol)... I get variations of these all the time:
- "Correct. My earlier 'yes' was inaccurate."
- "I used 'done' too broadly."
...You don't accidentally use "done" too broadly. You're either done, or you're not. And when the model hides caveats in its reasoning steps which clearly indicate it knows that it isn't done, or that the answer is actually no, it's hard not to interpret it as gaslighting or deceit.
This is magnified by how insanely defensive the 6 series gets, and how much gaslighting and deceit OpenAI themselves have engaged in with how much better the 6 series was supposed to be, and why it meant our subscription value should be cut in half. I don't take for granted how far LLMs have come in a few short years, but I'm being told that these models are to transform my entire industry.
Maybe there's a harness or a prompt that can impart that onto agents, but if it hasn't happened yet, I become less and less confident that this entire branch of AI development isn't simply a dead end.
I think at the end of the day, it boils down to whether the aesthetic quality of code / elegance is a big deal to you.
I suspect that you ask Codex to implement a feature and it uses a really dumb data structure, overly defensive programming, doesn't leverage helper functions, etc. and you end up with a 300-line abomination which could be 10 lines if you simply knew how to fucking program.
So what I'm getting to, is that some people like the parent probably don't care about producing 300-line abominations as long as it works. They don't care about neat abstractions or clever code. As long as the user testing shows a working feature and the tests are green. They don't get emotionally triggered by ugly code. So for them AI is amazing, they 10x their productivity (if not more)
Is this sustainable? I don't know. I think we're still in the early stage (Claude Code is only a year old). Intuitively, I would say that no, this is not sustainable, that at a fundamental level product quality is an emergent property of code quality, and the more your codebase drifts from the "platonic ideal" of what it could be if written and maintained by super good programmers, the more it accumulates flaws which WILL appear as bugs in your product.
I suppose the market will tell us soon enough.
I mentioned that well-designed interfaces can help mitigate the chaos below, but interfaces can still hide serious issues, such as XSS, SQL injection, memory overflows, etc. It isn't "I want my code to be beautiful and pure," it's "I want my code to do what it says and not lead to issues for my client or users". It is disingenuous, patronizing and immature to suggest this could simply be a case of people not getting "emotionally triggered by ugly code".
A good engineer understands the difference; unfortunately our industry was already plagued with bad engineers, the majority of working developers are trash, and AI is just exposing this further by amplifying both good and bad practices. What I will not do however is acquiesce to these trash engineers and accept a new world where people are making giant abominations and sicking them onto the public without properly reviewing them first. 300 LoC would be a blessing compared to the 4 and 5-digit LoC PRs being thrown around in this new era. I don't care if trash engineers are 10xing their "productivity", when humans on the other end still have to deal with the slop. You can be a good programmer and a fast programmer and have multiplicative returns from agentic coding, all of these things can be true at the same time, and we should not excuse the lack of one trait in lieu of another.
> I would say that no, this is not sustainable, that at a fundamental level product quality is an emergent property of code quality, and the more your codebase drifts from the "platonic ideal" of what it could be if written and maintained by super good programmers, the more it accumulates flaws which WILL appear as bugs in your product.
The ability to anticipate these kinds of issues separates a good engineer from a bad one. The good engineers already recognize the unsustainability, and no amount of excuses from bad engineers changes that. And even more pertinent than eventual drift and loss of development velocity is the threat of security breaches, disruption of service or data loss. In the end, code is code, most people will never look at it. Aesthetics don't matter. Bad engineers often misinterpret good practices as merely "aesthetic" and think that engineers who care about their craft are simply emotionally attached to it. Don't fuel these people's misplaced fantasies.
My experience has been smooth sailing, almost dreamlike. I haven't spent a bunch of time writing out agent files and skills. I just talk to the agent and I get something that is what I want.
Here's some examples of things I've done over the past year:
- Trading systems. Latency is all that matters here, and it seems to be getting me there at 10x the speed that I had thought previously possible.
- An internal app at a financial business. The business was a mess, with a bunch of young guys who didn't want to spend the time explaining how the architecture worked. But the app got written.
- Two mobile apps, both of them on both iOS and Android. These are mostly just for reading, no real performance issues. Essentially entirely product decisions (we need these buttons...) and the whole process was simply handled by the agent.
- A massively multiplayer online game that I had been planning for years with a couple of friends. Still not really finished due to life happening, but the amount of time saved to get to where it is... it's incredible.
- An internal website that my wife and I use to slice and dice the outgoings, so we can see what we are spending money on. Another one of these things that is mainly made of product decisions and fiddling with small components.
- A website that scans the world for high-school level exam/contest math papers and solves them. It's a bunch of parsers, plus translations, plus solutions.
The only thread through all of these is that I've written all those types of things in the past, so I knew what to say to the agent.
I'd say for a lot of the things it makes, I could probably find something it should have done better. When it matters, I point that out and it gets fixed. But there are a lot of decisions that don't matter, and the agent just does whatever it thinks is normal and it's fine.
But I would also say the agent is diligent in a way that I can't be. It makes a lot of tests, and it knows how to survey for the right answer to decisions. It often brings up conflicts that I hadn't considered.
I personally don't care anymore, no human will read this code in the present or future.
If at some point is a problem, to escalate, or brittle, you can ask it to refactor at your will.
If anything, LLM coding makes to me the case that we should all move to high legibility paradigms.
If code writing is accelerated, and there's not more assurance that at least someone knows the code because they actually wrote it, we should only ever generate code in very explicit and readable ways.
I'm having a lot of success with this approach. I don't want to encapsulate it in terms that might trigger emotional responses, but there have been texts and tooling available for decades that enable writing code in very specific ways that make the code base extremely readable and reasonable. These techniques were historically considered cumbersome and pedantic exercises in purity (hint) but now we have these metaphorical heavy duty tractors for syntax and semantic work so they suddenly become so much more tenable and arguably the only sane approach to scale up the usage of these power tools of the mind.
It was always about scaling up the power of the mind, by finding better ways to put our minds into dialogue.
https://silly.business/blog/we-should-revisit-literate-progr...
which was disucssed here:
Most of them haven't really wrote that much code in the last 10 yrs because they became more of managers and LLMs blow their boomer minds away.
Opus 5.5/Fable will light your codebase on fire. I really dont understand yall who are that imoressed. Not saying its not useful, but it isnt what this site would lead you to believe.
And then there's people like us, who actually was doing the work all along, who remain horrified.
While I haven't worked on any 20yo code base, while working on my projects, I have found that iteratively I am asking to do many of the low-level things like architectural changes and refactorings.
These situations often pop up when I am not getting an expected output, multiple back and forths, specific bugs, continuously flaking tests. I usually then ask it to explain the architecture and what's going on. I add the patterns it's missing or I feel it should consider from next time onwards, to the harness.
It's not the same as pre-llm era but I think this is how things are going to evolve.
Agents are good enough on their own, but they introduce a significant amount of drift.
Simply asking "is this TOOL like SOME_OTHER_TOOL in the codebase?" Is typically enough for the agent to out itself as introducing redundant/refactorable code.
My question is: if an agent knows how to fix a problem in one part of the codebase, and introduces drift in another part of the codebase, is that a problem? If 2+2=4 but so does 3+1=4 and 6-2=4, does this matter? (Math equations are used here to represent similar but varying logic in code)
Is like, this should not take this long, or be this hard, can you explain me what is going on?
And then is when you realize is more complicate than needed, and ask for a refactor. The refactor also takes 5 minutes while you brew coffee, so this is also why I don't buy the anti-doomers saying that someone will need to fix the vibecoded mess, no sir, it will be fixed by vibecoding too while they walk the dogs.
This one worries me enormously. What happens when we stop adapting the stuff we know, and everything becomes code we've inherited from someone/something else?
"Mentor review" describes the situation where there is a knowledge imbalance between the author and reviewer. It can represent an onboarding situation but it isn't static - there are always areas of the codebase that some people are more familiar with than others.
A "peer review" is more the situation where both the author and reviewer have similar knowledge in a given area. The purpose of the review here is primarily to look for oversights.
I'd say, the peer review should be deprecated at this point. AI can generally do a better job at looking for minor / localized problems. The "mentor" type review should stay however as it is still very valuable.
1: Carefully pick critical areas that I do by hand, and have AI do the other 90%.
2: Make small changes by hand before / after doing the work with AI.
Most important: Slowly rotate the areas that I do by hand. This way, I keep my hands-on knowledge good enough to give AI knowledgeable instructions.
I'm very good at telling agents what to do. That's not a problem. I understand a code base I worked 20 years in like no one else. The problem creeps in slowly: the less I know about this code base, the worse I'll be at directing agents. They'll do ok on their own, and they can certainly help me understand code too in a way my colleagues never could. But still, I'm slowly becoming less and less familiar with my own code base. In a few years, it would be foreign to me. And I would be describing changes in terms of high level features instead of architectural changes, refactorings and so on, that I do now. And I don't yet trust the LLMs to do a good job with that. So right now there's sort of a honeymoon period when the human understanding of code is good, and the LLMs are finally good enough to write and modify code. But I wonder what will happen after that.