I'm an avid Codex user and I can't work on 2 important things at the same time with it
If I do I can't keep it all in my head, I autopilot and let it rip and it ends up with shit solutions that I have to revert and remake properly
Method is 1 hard problem with pen and paper and docs and 1 slave job that's really hard to fuck up and is just a pain to type out, something that feels like a waste of time and resources I could be putting to harder problems that are much more design-oriented
This way I don't make huge mistakes because I'm always tapped in and I can see if something is not going in the right direction, so even if it feels slower it feels much better because I'm still thinking about contracts, abstractions, invariants but I'm pretty sure it's much faster overall because I don't have to restart ever (and cleaning up slop is ROUGH so I'd rather not do it either)
I very much so dislike the slot machine argument that people are throwing around because yes obviously you can use it like that but you can use it in smarter ways so it can do work for you that's a pain to do manually and is not that critical. It's pretty good at designing experiments with the right directions so you can test a lot of things in a short amount of time.
With the right supervision you can even let it do critical work but it really just works as an abstraction over typing but it can give you directions you didn't think about if you ask it.
Software design, logic (Software Foundations) are more important than ever if you're using these tools. Quality of thinking, precise specs and constraints, clear control and data flow design so you can eliminate potential errors even while designing not just when you're actually getting code out.
So if you give it all the control don't be surprised if it converges to average even with all the post training RL
Don't outsource all your thinking, keep it to yourself and use it like the tool it is
LLMs have made code cheap.
So now people are spinning up 10 agents working on 10 features in parallel. Sounds productive.
But the tradeoff is obvious: the code quality is often spaghetti over-engineered.
LLMs behave like over-eager interns. They will do more than asked, add abstractions you didn’t need, and optimize for "completeness" over simplicity.
Which means you end up babysitting anyway.
For anything non-trivial, I have found you still need to spend 1–3 hours upfront:
• defining scope
• writing clear specs
• thinking through system boundaries
• setting constraints
Otherwise, the system drifts.
And even after that, you have to review the code.
They still hallucinate patterns, introduce unnecessary layers, or miss edge cases, even with detailed instructions.
A lot of people advocate "just let agents cook."
In practice, you're often getting 60-70% unnecessary code that increases:
• cognitive load
• onboarding time
• surface area for bugs
• long-term maintenance cost
For side projects, this is fine.
But for real systems with shared codebases, multiple engineers, and production traffic, this compounds fast.
We are already seeing:
• unstable tools
• memory leaks
• constant crashes
• frequent rewrites
This isn't just "early days", it’s a direct result of speed > discipline.
Spinning up 10 agents feels like productivity.
But you are often just pulling forward the cost into refactoring hell.
I would rather:
build slower → keep systems simple → refactor less frequently
Good engineering is still about what you choose not to build.