I find myself pulled in two directions by the performance of coding agents: First, keeping them on a short leash seems sensible. I don't get failed results very often. When I first started using coding agents, this seemed not just sensible but required in order to not deal with a lot of hallucinated weirdness. Secondly though, it's pretty cool to vaguely wave your hands in a certain direction and get both user interface and business logic that's objectively nicer than I would've gotten from the effort I would've put into manually coding. Whenever I cautiously use a coding agent, I wonder what I am missing by not letting it cook.
I don't understand why that idea was adopted that IA had to be that "give one command have a perfect run and correct answer" thing when it's clearly not how it works and an eternal "the last % is worth 99%" issue.
I know why the US frontier labs push it of course, you can't push a trillion dollar plus idea if you also say it should be a cheap commodity and the best and latest are now the answer, a bazillion mid levels are.
But most work of value I do is with a swarm of "not the latest nor the brightest" models, with a smart one controlling the dance. Most decisions or review is better done through consensus. The myth that "if we keep going it will reach a point where it's always correct" seems so obvious to me, it doesn't work like that, for that matter we don't work like that.
This is not a jab at it. I work with it. I love it. But I think the story imperative are a mismatch for the actual needs of most companies, and it's hiding between the "frontier needs" of special research & co, or the governemental needs.
On the same line of thought: it's pretty obvious as great as these things are, no they're not going to "replace all employee", and no employee without them won't be able to compete either. They're a supercharger, a self multiplying smart assistant with capabilities in any field, and it feels so wrong to me that they've been presented in a complelty different way.
Keeping them on a short leash is leetcoding. Handing them one recursive function at a time
Devs are the PMs structuring the sprints now cause they know when/where/how to pivot
See discourse wrt who Nvy should pick as ceo (if JH doesn't come back anyway); at least from what I seen the theme is if they are not an engineer who can keep up with tech and know why Nvidia needs to change course Nvidia is toast
Same with software; everywhere I worked PMs that were not engineers sucked to be at as the PMs Duning-Kruger called the shots not the demands of technical problems before the devs
I appeal to fellow engineers too; consider in this transition into poly-job expertise phase to explore and apply them edge case solving skills to the domain of law.
4+ million devs in the US. 1.3 million lawyers. Just 1/3 of devs pivoting would act like a massive forcing function
And local/hosted AI assistants can flatten the learning curve.
Been looking into pre-law courses. Scoring a 71 of 100 on a mock bar exam without studying made me realize that stuff is high school level logic. So imma keep going for now. See where it leads.
> objectively nicer than I would've gotten from the effort I would've put into manually coding
I find that only works with topics I know very little about.
Not every problem should (or even could sometimes) be solved the same way. Are you planning to maintain the produced code for more than a year? No, then wave away. But if you're expecting others to depend on it, and you want to be able to continue evolving what it is, then a tight leash and full understanding of how it actually works, is very much needed, even if you don't actually type characters into an editor anymore.
Otherwise you still end up with balls of spaghetti where each change takes longer and longer to work into the codebase. With a bit of planning, you can keep tackling changes and they keep taking the same amount of time more or less.
[flagged]
[flagged]
I think Conway's law applies. In an ideal situation your code mimics your organisational structure.
The places where you let an agent do its thing is bound by the (implicit) interface your prompt creates. In an ideal situation this interface is a simple isolated thing in your application.
If you just let it do its thing, expect a monolith. You shouldn't rely on it coming up with interfaces that mesh well with what you had in mind, and each of those interfaces represents a decision that it took, restricting future iterations of the code. So a monolith is not only what you can expect, but also the best you can hope for.
If you want to let it cook, create more places for code that does a thing and you don't care how.