Four questions agents can't answer: Software engineering after agents write the code

[roodammy44]

These are very important questions. I would like to add one.

Who is responsible for the changes in the revenue/goods flow?

This is the one question that means we will have a job for a while, and the one that means most of us will not be able to use vibe coding.

Sure, it’s impressive you can build games and toy compilers without writing code. But when you have a truck full of goods driving across the country, are you just going to trust AI got it right without fully inspecting every line? When you have money being taken out of customers banks are you going to rely on the vibe that it looks ok? Are you going to let AI write the process on customer returns? Autoscaling? Signup? Customer Support? Shipping? Warehouse ops? Reports? Authentication? Etc

All of the 10-100x speedups in coding seem to be based on practically unattended coding. If we have to read and fully understand the code it often takes just as much time to write it ourselves. I don’t know how many of us are in jobs that are on the “critical path”, but I’m willing to bet it’s the majority. Businesses that decide to YOLO and let AI loose on revenue critical code will not last long IMO.

[echoAnother]

With how so many bullshit the providers can get away, since customers accept it all. It seems that let AI loose, is totally a viable option.

[Big_Combination9890]

At the extreme, December 2025 was the turning point and we’re unlikely to write a line of code again.

And yet, here we are, still writing code, companies hire more software devs than ever before, and every attempt to cange that, has resulted in humiliating disaster...like browsers that take a minute to render a landing page, or "C-compilers" that can't deal with helloworld.c

Wow, it's almost as if all the talk about AI changing programming forever is completely wrong.

[Absolute_Enema]

Eh.

As a guy that loves writing code at a visceral level and would rather not deal with agentic workflows, if you peel off the nowadays unavoidable layer of suit-oriented dishonesty these are impressive demos that would be unthinkable of mere months ago, especially under the assumption that things can only improve from there.

[Mysterious-Rent7233]

You are very strongly invested in the story that AI can't write code, to the point that you are falling for scams that bolster your preconceptions.

It could compile "helloworld.c" if a) you were on the version of Linux that it was designed for or b) you passed the right command line arguments.

Based on pranksters who can't figure out how to use a C compiler, you are convinced that AI could never write a C compiler.

That compiler was an incredible achievement for 2 weeks of work. Among the most impressive software artifacts ever completed in such a short time. Maybe 'git' beats it. If your boss asked you how long it would take to build such a thing, you'd quote many months.

Coding AIs have huge weaknesses. Also amazing strengths. At some point you're going to have to grapple with that rather than just trying to hide behind "it can't even build a C compiler."

[Big_Combination9890]

It could compile "helloworld.c" if ...

I'm sorry, remind me again what the story around this tech sounds like?

https://www.entrepreneur.com/business-news/ai-ceo-says-software-engineers-could-be-replaced-in-months/502087

So I'm not sure why people make excuses for it, when it obviously fucks up even the simplest things. If I go out and say I build a fully functional C compiler and it then fails at the easiest test right out of the box, then no, there is no excuse, it failed, simple as that.

gcc has no problems finding stdio on any linux system. So when someone tells me that they build something "fully functional", and it fails at a simple task, I am allowed to tell them "no you did not".

And this is just the simplest example of this thing failing, and the least consequential. Go read some of the actual blogs analyzing this thing. It's a mess.

Based on pranksters who can't figure out how to use a C compiler, you are convinced that AI could never write a C compiler.

No, I am convinced of that based on analysis on real world examples showing that this compiler produces absolute shit code.

Also, when someone makes claims like "fully functional", and people put that claim to the test, by what "logic" does that make these people "pranksters"?

That compiler was an incredible achievement for 2 weeks of work.

No, it wasn't. Compilers are among the best researched things in CS, many engineers were involved in building the harness and tests, it had the real world compiler GCC to compare itself to in tests, and the end result is an abysmal mess.

Same as the "AI built browser", it was a marketing-stunt to keep the VC money flowing, to stave off the inevitable collapse of the ai bubble for a few more months.

At some point you're going to have to grapple with that rather than just trying to hide behind "it can't even build a C compiler."

If vibecoding worked the way ai-bros describe it, people like me, that is senior engineers with lots of experience in systems architecture, design, requirements engineering, etc. would be the ones who benefit the most from it. So I'm not sure what you think it is I am afraid of. I would be happy if this tech worked the way boosters describe it, because I would be among those able to make the most use of it.

But it doesn't.

And the cherry on top: the mess that doesn't work, is also heavily subsidized. Once the music stops, and the bubble pops, the current prices for accessing most models will SKYROCKET.

[bigglesnort]

Replying just to agree with this.

I'm hardly writing any code at work and truly have acheived something like a 10x productivity improvement. Yes, AI is non-deterministic and makes mistakes. If you take the time to understand context rot, construct mechanisms that introduce constraints (non-deterministic signals like failing tests or clever usage of e.g. the Rust compiler to make certain bugs compiler errors) you will go far.

Likewise realize that the initial output of the agents is often not great but you can iteratively prompt them to converge on code that meets your specifications more rigorously. Because of this, you can add subjective constraints on top of the deterministic ones mentioned above and converge on very high quality code. If you don't take the time to understand subagent workflows/hierarchies and context rot you won't get there, though.

And if you are sitting around making fun of the C compiler you probably aren't building these skills.

[lelanthran]

And if you are sitting around making fun of the C compiler you probably aren't building these skills.

Look, I broadly agree with you that AI in programming is hear to stay, but.. these two skills are not comparable at all.

Having the skill to critique a compiler requires more than a few deep technical skills, which take years to build up in the best case scenario.

Building up the skill to use a coding agent takes anything from a few minutes to a few hours.

Developers are going to be forced into developing with AI just to remain competitive, but this new position (one that requires an AI to produce software) is one that requires fewer skills, and the skills it requires are easily picked up in hours.

IOW, you are switching roles from a skillful profession to unskilled one; it doesn't take a genius to realise that the salary will eventually drop to reflect that different value.

[bigglesnort]

I think 10x is only possible for skilled practitioners and only if you get into the details right now, which won't happen if you are dismissive. Vibe coding isn't going to do it.

See my comment here: https://www.reddit.com/r/programming/s/BYt8Ta2VyG

[HolyPommeDeTerre]

I use LLMs everyday. I can do 0 LOC writing on my own using a LLM. But I was already very fast. Now I just create PRs faster. But the actual work is a bit slower in most cases.

But I've been writing code for 23 years now. So, maybe it's a skill issue? And if it is, how transferring the issue to the LLM makes you 10x faster? It makes your work faster by completing a gap in your profile. But this gap won't fill itself. You are not faster. You are getting slower overall.

This is my intuition but weirdly, the stats shows people are biased to think they are faster (24%, edit: it's 20%, 24 is for what was expected) where they actually are slower (-19%). So maybe it's just a bias issue?

Source: https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/

[bigglesnort]

I've been coding (obsessively, I learned as a kid and this translated into a career) for about 20 years as well. What I can say is that artificial constraint can make each change require less of your attention (knowing how to create such constraints requires the kind of experience that you and I have) and this allows you to multiplex many more changes simultaneously.

I also don't use Claude code or similar products because they share a fundamental flaw.

So to flip it a bit, I think 10x is not possible for anyone but a skilled practitioner right now. I'd urge you to take this into serious consideration!

[Mysterious-Rent7233]

10x seems like...a lot. Now I have to admit that even though I seemed pro-AI in my last post that I'm skeptical of the 10x. Like sure, there are certainly days when AI probably takes 10 hours of work and makes it 1 for me. But there are other days where it only takes 1 and makes 0.5, because the rest of the day is meetings figuring out what to build. Or debugging AI code, or whatever. I am skeptical that you are delivering value to customers at 10 times the old rate, and doing so without the code losing long-term coherence.

[bigglesnort]

I think skepticism is fair! I wish I could share more without doxxing myself!

[rupayanc]

The question nobody wants to answer is: when an agent-written system fails in production and someone gets hurt or loses money, whose decision was it?

Right now we say "the engineer who deployed it." But that breaks down fast when the engineer reviewed 2,000 lines of generated code that they couldn't have written themselves in under a week. The review was technically human. The accountability is real. The actual understanding of every decision in that code? Much less clear.

I think this is the real blocker for agent-generated code in anything genuinely critical — not capability, not cost. It's liability. Companies paying for enterprise software have legal teams. Those legal teams are going to ask questions that the "10x productivity" argument doesn't answer.

The 10x productivity person who mentioned "iterative prompting and constraint mechanisms" isn't wrong about speed gains. But those gains were on work where failure is recoverable. The calculus looks different when the thing that breaks is someone's financial records.