People these days are saying “don’t look at the code”.
People are shipping all sorts of weird architectures, non-performance code, etc.
I wish that the ram scarcity would drive more performant software however I just think that the way people are shipping software currently will not lead to this
How does everyone feel about the “don’t read the code” stuff that folks are saying? I certainly do not support it but I’m curious to hear what other folks thoughts are
I believe it's only a strategy that works in the short-term. If you ever expect the software to be stable, quality, and human-maintainable, you're going to need a good test suite (hopefully not AI-generated) to get away with that little ownership of the code. That said, this is great for prototypes or throw-away software, provided you don't mind being entirely reliant on an LLM for maintaining the code (speaking from experience, a human usually does not want to touch a fully vibe-coded application that they've never reviewed).
If I'm wrong about this, I would expect to see a new field of LLM-automated software engineering with at least the same level of rigor and quality as the existing human-led processes, and in the absence of this, we're just further degrading software quality for dubious gains (is it to go "faster", is it because we are being compelled to by leadership, is it out of fear of being left behind by competitors?). I can't imagine any other engineering discipline as critical as software being "vibed" - if I had learned that the local bridge had no human inspection, simply was "vibe-checked", it might be a good bridge, but I'm not going to be the one to test it.
It seems like a huge mixed bag. I have coworkers that has been able to "vibe" entire systems that somehow manage to work, but there's a lot of churn, weird bugs, and a huge reliance on <agent tools> to make any progress. Sometimes "good enough" is just that, sometimes it isn't.
On the one hand, if you really want to unlock the potential of coding agents you can get a whole lot more value from them if you don't force yourself to read every line of code they produce for you.
On the other hand, that's clearly a terrible idea! These machines make mistakes. Unreviewed code is the most obvious form of technical debt - sure, you'll get a boost in the short term but how much will you regret it later?
Something that's helped me a bit is thinking about how I've collaborated with other teams at large companies. If my team depended on some other team's product I wouldn't review every line of their code before using it - I'd start using it, then if I ran into problems I'd dig into the code to see if I could figure out the problem.
That works with human teams because humans can take accountability for their work. Agents can't.
And yet... the more time I spend with specific agents, the more I learn what kind of problems I can "trust" them with.
If I ask Codex or Claude Code to build me an API endpoint that queries a database and returns JSON, including with tests, they're going to get that right. I can glance at the shape of the tests, hit the endpoint with curl, and be confident that the job is "good enough" without me reviewing every line.
Over time, the pool of tasks like that which I'm confident they're not going to screw up has grown.
A big part of the craft of using these things is developing the instincts to know when you need to dive in to the details and when you can relax a little.
Having a lot of experience helps a ton here. I have 25+ years of experience to help me make these judgement calls. If it's security adjacent I know to review much more thoroughly. I have a good idea for the kind of mistakes that can be made. I know what shape I like my tests in, and how to both manually and get-the-agent-to-manually test things.
I agree with this. I am also starting to get a "feeling" of when I can trust an agent and when I can't. Recently I had it throw together a dashboard that displayed some basic linear models based on knobs on the dash, and I didn't really worry about it getting those wrong (I did spot check and it seemed good). But I also had to update a pretty complex flink app with state management changes that it totally borked.
The first task was more self constrained and less production impacting. The latter was detail oriented and required understanding complex distributed systems and state.
I would like to be able to formalize these kinds of tasks. I believe there are lots of confounding variables:
- Access to MCPs
- quality of documentation
- strong existing practices
- examples of similar code nearby
And then we can more easily determine what can be totally handed off and what can't be. I think that last one is most important, but similarly:
- how much this type of algo appears in the training set
Which is maybe part of the "feeling" that we have about what it will do well.
Extremely silly. Even if LLMs did everything that everyone says they do (which they absolutely don't), they still hit a fundamental limit of complexity when they stop being useful
Its only a good idea if you work in selling tokens, otherwise you're dooming anything other than a simple app to inevitably breaking after it hits a certain level of complexity
I have used LLMs for safety sensitive tech writing and so have people I know. It’s pretty good at it, and you usually have a 95% ready to go product at the end of it. The last 5% can pretty easily be filled in by technical experts with way less time spent battling the type writer.
Is it perfect? No. But it suffices most of the time in a pinch.
Can’t speak to the nuke industry, but it’s pretty good at aviation related things.
You tell it what you need, and it pretty much does all the work:
> please give me a 135 compliant maintenance manual, use the attached document as a primer, reference every part 135, 91, 43, and 65 reg as appropriate as well as the other included manuals. Make sure to reference every requirement in the attached list of requirements. Aircraft mx manuals are in the folder “mx-manuals” and our current forms are pdfs in the “forms” folder. Remember our operation is <describe scope of operation here>, not a major airline. Have fun!
This does surprisingly well and meets requirements at about 95% or better accuracy. Typically the only problem I routinely is trying to make the manual like a Delta Air Lines manual instead of one for a small air taxi.
This! I don't think folks understand how easy it is to go from greenfield to brownfield with these tools, esp if your organization is only valuing velocity. Meaning your doing full agentic development on large features, barely reviewing any code, and shipping without much refinement. It's insane, but this appears to be the status quo in SF startups.
This was said recently lolol
https://x.com/bcherny/status/2090649326032945591