[steve_adams_86]

I work with people who generate solutions without really looking at what was produced (group A). They click around the app or run some tests and decide if they're content with the result, then ship it. You can see Claude's fingerprints all over the PR and it's safe to assume they didn't change much of anything.

Then I have coworkers who work through the problems, build harnesses to test the changes and verify results, work through multiple solutions, synthesize ideal outcomes into a single one, benchmark, refine, test the result thoroughly, and provide sane verification processes in the PR. This is group B.

They're entirely different versions of using AI. One seems passable for now (look how fast we're going!), and the other is arguably a new version of what's possible (in a given time frame at least) and defines a totally new normal for software engineering that I virtually never saw outside of exceptionally professional contexts. You don't move as quickly as group A, but you still move faster and produce better software than most people have in virtually every company I've worked for.

I see group A being totally pushed out of the field fairly quickly. LLMs let you work incredibly effectively if you care to learn how. That kind of rigor is going to be the default (group B), and might become the only way humans can still be a useful component in the loop. Group A is likely to become replaceable with frontier models before very long.

[i_love_retros]

Bro group B might as well write the code themselves. this is getting silly

[steve_adams_86]

I don't agree.

There are large yet trivially generated change sets that you can trust an LLM to do, and review easily. There are large errors LLMs are incredible at parsing and inferring causes from. There are unstructured logs you can feed into an LLM and get meaningful information out of. You can save yourself a tremendous amount of time if you know when to use them.

Then there are test and analysis harnesses, scripts for performing rudimentary tasks, having them fetch data from disparate sources and synthesizing them in one place. This is all extremely helpful.

I was skeptical for a long time, but it's a significant multiplier now. I write a lot of code myself still, I review everything, but so much of what the LLM does is supplementary to the outputs. They evaluate, unblock, inform, and triage well enough and so ridiculously quickly that being correct even 70% of the time is still useful. It doesn't take much guidance and guard railing to get them well above that metric.

[rTX5CMRXIfFG]

Dear god no, I actually want AI to write the code that integrates my unit-testable abstractions into the existing spaghetti. I don’t care how it does it, the thing just needs to work. The moron that wrote the mess didn’t care enough to begin with, why should I? But all work moving forward must only be made of the good stuff

Not silly

[le-mark]

The great thing about spaghetti is you only have to be as smart as the person(s) who wrote it; there’s generally a self enforced bound on how obtuse it can be.