The Mythical Man-Month in the Age of AI

That doesn't work if the driver cannot steer properly. It's the main issue with vibe-coded one-shotted solutions, that might look impressive until you peek underneath and it's all a mess.

Is this sustainable? I've got no idea.

While we may use deterministic tools like static code analysis, dependency scanners and similar today, people are already replacing/augmenting them with LLMs.

While every breach will trigger a root cause analysis process in a compliant environment, the solution is never going to be "all code in a deployment was manually reviewed by someone at the company" because this would extend to tooling (like compilers, scanners but also packaging and deployment tools) and all dependencies.

So I am pretty sure your example is already used in a number of places especially with "LLMs are better at security than humans" marketing being pushed around — this really makes it easy to sell that excuse to the gullible management who wants to believe this.

The thing is it gets you the wrong answer so fast it’s now the best way to figure out the right requirements.

Those aren't always true. Sometimes it takes a while to see the fatal flaw in an approach, and sometimes having a bunch of failed attempts isn't enough to make the right way obvious, and thinking is still required.

1. A blank sheet of paper

2. A one-shotted POC in the span of an hour with $4 of tokens that is clearly wrong in 20 different ways?

Not quite as shocking as the original InstructGPT video, but surprising.

It can then raise, investigate and resolve those problems while also patching up and rationalising logging to improve future work.

The AI deniers have their heads in the sands at this point and are demonstrating they simply haven't tried a modern agent. ( Or perhaps are forced onto copilot? )

Could be either, but also the free version of ChatGPT seems rather braindead compared to the paid version, or to the free version of Claude.

What some of us are saying is that AI is poor at figuring out what to build, how best to architecture it, and what to avoid.

Absolutely not at all. Every single day that I work with Claude, there is abundant evidence that AI sucks at these. Ask me for examples if you need them.

https://news.ycombinator.com/item?id=50220976

https://news.ycombinator.com/item?id=50165791

https://news.ycombinator.com/item?id=50159827

The first links shows a basic failure of reasoning, which would have gone unnoticed if I was just vibe-coding.

The second link shows weak architectural sense and an inability to see the big picture.

The last link in particular is telling: the agents worked with me (over weeks to months) to implement a db abstraction layer without ever bringing up the fact that as it stands, that would have never worked with any indexes at all. I did not constrain them to my choices, but they never stopped me with that design. It took my eagle-eyed attention to their offhand comments to notice this problem, which then required a lot of rework to fix.

For flagged threads, you can go to:

https://news.ycombinator.com/active

But it was pretty eye-opening to see how good it was at watching a user struggle and identifying possible fixes.

In my opinion, a good engineer is not good because he understands every single obscure technical detail, but because he can build solutions that the people using his technology actually want. The list of things they don't want on the other hand is endless.

Definitely this. I've had plenty of useless meetings with no helpful outcomes that lasted an hour with 6 or more people in them, and a few of them will have had more than $4 spent on snacks, let alone everyone's wages.

That said, poor communication will always get you no matter what: had one day spent going back and forth with a client, they kept saying they wanted a button "wider" each time around, I ended up making it full screen width and they still said "wider", asked them to draw a picture and they finally said "wider vertically". That may or may not have been faster with an LLM, depending on if the LLM ever thought to ask the client to draw what they meant, but fundamentally would have been exactly the same problem.

A meeting between all the stakeholders to agree on requirements easily runs $1,000/hour. Taking your $4 functional PoC into that meeting is going to save so much time...

Now LLMs make that easier to do with a larger scope.

Draw outlines, or use graphics, wire up clickable areas, and interaction flows, and you’ve got a presentable “live” demo that doesn’t run afoul of issues presenting demo sites to non-techies (placeholder text, ugly buttons, test domains, colours, etc).

It is though! Because previously your have the meeting last 4x as long to end up with a list of notes that you already knew.

Now you can generate the PoC, showcase it during the meeting and leave with actionable changes in project direction.

Not everyone in meeting will be the same person you are. Visuals help. Prototypes help. They certainly can save us from vague ideas and unclear language, because at least someone can point to the big button at the bottom and say:

"Can I have this in cornflower blue?"

It is useful, simply because it makes it more concrete. Will it change? Is the pope catholic?

As a counterpoint, bringing a one-shotted POC without thought may actually do have a shock and awe sort of effect, dazzling the stakeholders to go down the wrong path since the AI prototype was so easy.

Scrooge McDuck lived by the credo: "Work smarter; not harder."

But for many people, smarter is harder.

It plays into the generalisation that people aren't good about saying what is the right way to do something, but much more open to saying what something is doing the wrong way.

In a previous job we used to do prototypes in languages like Perl because we couldn't ship them and knocking something non-production ready was easy. We were able to quickly come up with the PoC, iterate on it, and then plan and write the whole thing in $LANGUAGE_OF_CHOICE.

I also prefer doing a POC, but it's not without risk, especially if your stakeholders are just a bit too eager. Another problem I've seen is that a POC can hide complexity, so a lot of weight is on you as the author to do the due diligence before and bring that along.

The last thing we wanted was for an "Isn't it neat?!" hacked-together demo to be mistaken for something shippable, if workable at all.

As long as someone doesn't go - "Why do we need requirements, you've built the system already!"....

One example: setting the agent ablaze on some task, keeping it going, and after a few days of working with the agent you have a feature. But it's not what you were supposed to make. The agent didn't have all the context and made something slightly off, and you never internalized the problem enough to even spot it. If you actually stopped to think a bit on how the feature would have to work to tie it in with everything else, like you would have done before, you would've spotted it.

Second example: something wasn't feasible to do before, due to not being worth the time investment. Like a feature that would need a bigger architectural change to implement. You and the agent take a crack at it, and rewrite huge parts of the code, and it seems to work. But now no one understands how, and it might have been the wrong way to solve it, you just went with it. Before, you would've sat down and discussed and thought about the architectural tradeoffs. Now one decision was just made with little thought.

Real life is full of unknown unknowns, AI risks putting you on the wrong path without you even realizing it.

It doesn't help a bit that (almost? I'd say all) AI products are very confident while they're guiding you on that unknown unknown path, so of course that you don't realize soon enough the epistemological situation said AI product has driven you into.

I used to do the same thing without AI, I'd spend a week working on a task and only realizing at the end it was wrong, but because I spend so much time on it, I was incentived more to keep going and ignoring sunk-cost.

Now I don't care, it only takes me a an hour and I have no problems throwing it away and trying something else.

I've seen the same behavior using AI. They just keep double it down without seeking human feedback nor asking themselves if there's prior art tackling the same problem. At the end, they don't only get into sunk cost fallacy but also go into a shadow IT journey achieving generational tech debt in a few weeks.

If you didn't allow yourself for a feedback loop venue and constructive feedback from peers, AI will not solve that issue.

If the situation that you have to convince a programmer to stop working on something is something that happens more often than very rarely is in my opinion a strong sign of bad leadership. These are people who are really in love with what they are doing and are thus so attached to it, and you want to cast out this love for working?

So, the moral that I can only get from your post is:

- AI can be used as a mitigation for bad leadership.

- Programmers should care much less about the work that they do.

I see people ship a half baked feature then spend the next weeks ripping and replacing huge pieces causing all sorts of issues

Much easier to engineers to move to product than product to move to engineers. Or at least the minimum amount needed to fill all product roles. I’m seeing we can do that now and it’s _much_ more efficient to not have to have back and forth communication as in the past with that communication being by far the slowest part of build processes.

One can have this stance. But in practice, programmers who have strong opinions on this topic that is not aligned to the management wishes will commonly become personae non gratae in the company, and are thus commonly on the brink of getting fired.

So, in the end, the incentives that exist in most companies are strongly biased towards the position that figuring out if you're building the right thing is the job of the managers and product owners. :-(

For the way orgs are currently set up, yes, conflict between engineers and management can cause issues. I'd put somewhat of a bet that those types of org setups won't be the way in the future.

If the engineer is told to build a bridge that is virtually guaranteed to collapse, then it a reasonable person ( ideally, same person as engineer ) would note that particular risk.

It may not be engineer's responsibility to build the exact right thing, but it sure is their responsibility to build it right without having the bridge to collapse the moment someone stands on it.

Otherwise, the person building the bridge is not an engineer.

One is likely not an engineer if one does not notice the risk. But in practice, managers commonly desire docile subordinates, so the only thing an engineer can do in such a situation is to ensure that a paper trail gets generated that will be capable of breaking the manager's neck once the disaster has occurred. :-(

If you don't understand what you are building, chances are you'll take suboptimal decisions or even come up with a solution that completely misses the point.

To properly understand what you are going to build, it's not enough to read specifications from some manager as gospel. You need to ask questions, and challenge the requirements sometimes, to make them your own.

Many managers don't like being challenged. :-(

I feel like going slower gives you time to let the details form the solution. You think “hm maybe that doesn’t make as much sense as I thought, maybe there’s a better way to frame the issue…”. If you don’t let a problem really soak in, you don’t get the “hammock driven development” that Rich Hickey talks about.

Of course some problems don’t need to soak in. A lot of problems just need code to be cranked out. I love slopping together a monster script that solves exactly one problem perfectly

Same with demo. Do a rough wireframe or something with default bootstrap style and it’s way easier to target the meat of the problem. Not so much on a full site

Always easier to discuss what the client actually wants if you've got a demo on the table.

I'm doing short feedback loops with product owners more and more - sometimes within the same sprint. I'm not even getting bikeshedding back, but that might be because we have some fairly solid design guidelines.

I guess that’s just the old “Build One To Throw Away” in a modern light, where prototyping more freely is now actually feasible. I think if you apply the good engineering ideas of the past decades to AI, the results can be really good!

Except I’d also add a lot of testing to the prototype, to bring up as many edge cases as possible.

If oftentimes happens that you don't know that that's the wrong answer, or you don't realize it right away, for that matter, and hence that's I think that AI is a new (and very big and important) source of information entropy.

Just a recent personal example, yesterday I was curious about the historical figure that was present in an online photo taken in 1930s Romania. Google's Gemini was very quick to point out that that was (military dictator) Ion Antonescu [1], which it was obvious that he wasn't. I wrote down that that wasn't in fact Ion Antonescu, at which point Gemini was very quickly and very surely providing me the info that that guy indeed wasn't Ion Antonescu, but (former Foreign Affairs) minister Manoilescu. At this point I wasn't so sure myself, I don't have a visual image of Manoilescu in my head, so (ironically) I had to AI-dumb google for Manoilescu's available online images and it seemed like Gemini had been wrong a second time. I didn't bother asking it for a third time.

Just to put things into perspective, here in Romania it is illegal to mention Ion Antonescu's name (and propaganda image) in a positive matter, as in one risks prison for doing that, now, just imagine that the political powers that be here decide to use an AI-tool like Gemini in order to identify potential law-breakers in that respect. People would risk going to jail just because Google's Gemini was completely wrong in identifying a WW2 military dictator. Absolutely atrocious product(s).

[1] https://en.wikipedia.org/wiki/Ion_Antonescu

Someone has to sign off on the requirements and also what is released. So, two approval steps by a person. The first approval is for a plan and the acceptance criteria. The second approval is a check against the plan. The agents can do all the work of taking the plan, breaking it down into tasks, building, and then verifying it. A good orchestrator will include people in the workflow at the points where their decisions matter and maintain a record of it.

The idea is that instead doing things correctly, you do "something", then, if it fails (it will), you change some random stuff until it passes. It typically results in code no one understands and that fails each time something unexpected happens.

AI makes the process much faster, but just as wrong.

Software engineering is almost always a process of iteration. The better you get at iterating, the better you are at engineering. This can take on a lot of forms (my old manager would constantly repeat the mantra "don't let perfect be the enemy of good," which is arguably a recognition of the same dynamic), but at the end of the day, if you expect to "one-shot" a complex implementation and you build a process around that assumption, then you will fail. Almost ironically, the best way to avoid that issue is to assume you will fail (potentially multiple times) and to build a process around that assumption.

Interestingly, it seems like a lot of experienced engineers I work with have just forgotten this concept in the world of AI. They expect AI to just get things perfect in one-shot and are dismayed when it fails. There's a lot of discussion around how we handle code reviews because some developers are just letting AI one-shot a solution then sending it to review. It boggles my mind that competent engineers aren't allowing their AI to fail, so to speak, and are instead wasting cycles trying to figure out how to get AI to produce the perfect solution the first time.

To me, it's obvious that there's just a fundamental gap in alignment that prevents a consistent "perfect one-shot" to probably ever be possible (at least, within the current paradigm of development). I can spend an hour writing a spec and try to include every little detail of context I can think of, but in what world could we expect anyone, let alone an AI, to be able to envision the solution the same way we can? We just lose way too much information through communication for that to ever be possible. Yet I see people very dismissive of the capabilities of AI because it's not literally magic.

Very weird way to say this. Like it holds true for biological beings because pregnancy by default has a fixed timeline. But how does this apply to AI? Also what even is an "agent"? Are they distinct worker units on a program or the same worker unit split into multiple instances?

Why are we assuming agent = man when its a computer program?

It would be something like "nine women cannot deliver a baby in one month", which can be more easily transposed to "adding resources to a SW project does not make it faster".

The agrument is that adding people increase coordination and communication overhead, which gets bigger as the team grows. Moreover, some tasks cannot be parallelized that easily and create dependencies.

I have only worked with agents for personal projects, but I cannot say that explicity dividing the work between multiple agents and asking them to coordinate is inherently faster than having a single agent work on it (of course the single agent will spawn subagents in rencent harnesses.)

Agents still have to communicate using tokens (for now). There are more advanced mechanisms being proposed, but for now, and until proven otherwise, the same scaling problems apply to agents communicating as humans, it just happens a bit faster, and with no HR issues because someone slept with the wrong person. Mesh networking, and thus agents too, are beholden to Gupta-Kumar scaling law.

Anything grindy. Reverse engineering. Performance optimizations.

That's where swarms shine I think. But that's a much much much smaller problem space than what these agents are being sold for.

"You're absolutely right, that drug was lethal and that's on me. I'll add a note to check human toxicity for all compounds in the future. To verify the safe dosage, I'll administer a high dose and then check smaller doses until the patient survives — not guesswork, grounded, load-bearing experiments."

I think its practical to solve cancer on a war footing where we would expect people to die.

And Farber's methods were pretty fast for his time - lol Farber would be a perfect name for this AI that wants to solve cancer knowing what's at risk.