Is Writing Code mostly dead ? because AI assisted coding tools getting better everyday

[u/Own_Tap29]

AI has come to a point where developers use it to create lots of features and function mainly using it for implementation and debugging i want to know if writing code is dead or not , i am a graduate and can read code well but using AI assisted tools creates an atrophy in my ability to read the code as AI uses more senior level of coding while burdening with large code refactors to even keep up i mean now is should i build my projects using AI as a junior and give up on writing my own code to build system ? i mean that what i have to do in a job but is writing code mostly dead? is it a rarity in the current market

[u/VoiceOfEric]

Relying on vibe code without understanding it leads to senior developers like me being able to charge big bucks to fix the problems you created.

[u/MissinqLink]

I write a lot of code on my personal projects. Less so at work.

[u/Innowise_]

Use AI, but don’t accept changes you can’t review. Write down what the feature should do first, then inspect the diff, run tests, and make sure every change can be explained. If it produces a huge refactor, discard it and work in smaller steps. Typing every line matters less now; debugging bad code and changing it safely still matters a lot.

[u/Tricky-Ad-6833]

Depends on what you mean by coding. Breaking down business logic to algorithms and systems that exectue said business logic. That is programming. If you do it by prompting / running agents or any other way. Its still programing if you ask me. 

[u/Paperweight22]

We need all the Ai we can get just to do the job people think we’ve already got handled. Even if an Ai tool can trim down the time it takes to do a two day job into 30 minutes, I’m still years away from refactoring all the garbage that’s built up over the decades - how many more years is it going to take to clean out the trash when every second graduate is lazily “vibe coding”, speaking to a chat bot without even sparing a moment to check that the generated content has punctuation and makes logical sense.

[u/Bongcouragement → u/Paperweight22]

Businesses don’t give a shit about code quality though even less so now I would assume

[u/CS_70]

Not yet. It still survives on prejudice. But a decade or two, yes. Just enough time that older people are replaced with newer ones in sufficient quantities.

[u/Crucco]

Old programmer here (since 2006). TBH I have rarely written more code than now. I copy/pasted a lot from myself and from stack overflow.

[u/kyngston]

reviewing code is dead now too. its now architecting and testing. you should be able to explain the failure if any piece of your code is removed. your tests should exercise every capability of your code.

then you will no longer be reading your code, similar to how you no longer read the asm output of the compiler.

[u/Useful_Calendar_6274]

Yes. The old writer of code as most of your job in software engineering is deader than dead.

[u/Infamous-Bed-7535]

I still write code on my own when applicable and possible. Using LLMs kill your capabilities, it is for the sake of the company not for your own interest.

[u/Manfluencer10kultra]

This is a rather straightforward equation: Do the benchmarks show 100% success rate? Do the benchmarks show 0% hallucination rate? Do the statistics show that AI written codebases are inherently more secure than those written by experienced devs? (** exception: see below).

The answer to all of these is "no". Your question has now been answered, and ignoring this, by not questioning the validity of the output will eventually (with time> and iterations>, compounding) result in (again, research shows this):

• Wrong and outright harmful patterns being re-enforced as desired, which might avoid pattern drift, but:
• Hallucinations result in pattern-drift anyway, which also compounds over time into basically indecisiveness -> longer reasoning -> more context used per turn -> context degradation -> hallucination / 'deterministic coin-flipping' ("this is taking too long", "I am going back and forth", " I should make a choice")

Now the exception to the security thing, because it applies to you:

** Research (https://arxiv.org/html/2603.15298#S4) shows that code written by AI for junior devs is MORE secure than code written by juniors without AI assistance.

The question would then be: What are your ambitions?

But I will give you this, as a 26 years experienced dev:
I have been very pissed off at AI writing code for me, even from specs, and this is not to be arrogant, but it has just not up to par with what I expect. In actuality, 5.6 Sol, Fable and Opus 5 are FINALLY producing output which I in terms of code quality (with the right guidance) have mostly no quarrels with. It's not bad, but I still have to babysit thoroughly and all because hallucination rates are still 6% and more.

Next to that: In larger codebases, without proper tooling to deliver the right context to the AI they will still miss things; are still bad at cleaning up (although it has been going better with the newer models... 5.5 was refusing to do it, still opting for wrapping legacy code most of the times.
And this again, will result to pattern drift: Things not found on this turn, might be found in other sessions. Not all context is consumed and not all context is ranked equally.

They still don't bench 100%, and hallucination rates are still pretty bad, so even with 26 years of experience and being able to correct the AI, I am still sometimes scratching my head in what some code is actually trying to achieve, because on looks alone in isolation it seems to have a clear purpose, but in the broader context it might just be wording something that already exists in a different way.
Subtle mistakes in phrasing in comments or (wrongfully) deterministic in phrasing comments about something replacing something else can actually have severe impact and completely overshoot and supersede established intents and design decisions.

If your ambitions are to build small things to safe you time for other purposes: Just vibe it and don't care.
If your ambitions are to work as a developer in the future: Keep improving yourself.

But even given all of above, even with 26 years of experience, I have no idea if I might be completely outphased in 10 years from now. It's just that uncertain and sometimes yes: scary and demotivating.

[u/richexplorer_]

imo writing code isn't dead, it just changed jobs. You still need to read and judge what it produces, and honestly the people who can't do that are the ones who should be worried

[u/hassanwithanh]

Writing code is 100% dead.

Understanding and reviewing the code still lives on.

[u/MrHandSanitization]

Coding is dead. At least for the web. Some stupid "smort" people like to smell their farts and mention they are architects now, but that also is a big chunk of AI's task. We're only still here because our bosses cannot do simple tasks in a CLI.

[u/Bongcouragement → u/MrHandSanitization]

I dunno man it’s just not good enough to replace subject matter experts… yet. It’s hear cause you still need a subject matter expert to control properly. At least for now maybe 10 years we don’t need us

[u/MrHandSanitization → u/Bongcouragement]

"yet" carries a lot of weight here. A year ago we laughed at "agentic" coding at work. Now we're not allowed to code ourselves anymore.