grief the loss of code to see the road ahead

published: 10/10/2026

11 min read

back
Zoom overlay

from being laughed at as a “tab tab” autocomplete, to making us question our careers, llms has disrupted the software industry.

some say it helps them do more by running 10 agents at a time, while others say its shit because the code generated “is not good enough” or “not up to my standards”.

regardless of their views, since December 2025 / January 2026, i felt coding was on life support, and with every model release since then, coding is dead.

oh, i meant manual coding, like hand rolling code.

it’s been three months since:

instead, i’ve been side questing. learning hardware, electrical engineering and personal training.

i thought these activities were creating some space for me to make sense of what’s going on in this chaotic environment.

but i was wrong.

in reality, all it did was give me an outlet to grieve the loss of coding.

the five stages of grief

hand rolling code was a huge part software engineering.

most engineering decision made came down to: “how much effort is needed and the amount of code we needed to write for (refactor/implement/delete/write test/ and so on)”.

this hugely influenced our priorities:

however, with llms we are no longer constraint by the effort required to write code.

we can type in natural language, and with precise enough instructions it gets the job done.

thus, a core part of me (writing code) as an engineer, was ripped away seemingly overnight.

and i didn’t realise this would upset me in this way.

looking back, for the past three months i’ve been griefing the loss of coding in five stages:

denial

it all started during 2022, when ChatGPT and gpt 3.5 came out.

i was at work and my leads were nudging us to use it for writing test and autocompleting smaller function to be “faster”.

my first reaction was: “no way it can beat hand written code”.

so both me and my colleagues, tried it out a few times, and we dismissed it as coding autocomplete.

moreover, it was creating more work for us. we had to read huge chunks of test code before realising half of it didn’t make sense and the other half was hallucinated.

there was a lot of promise of it getting better with every model release, but i was quite skeptical due to the slow rate of model releases (every six months) and high training cost.

anyways, i kept playing with it to get a sense of how it was performing, and the outputs weren’t “satisfactory”

until it was.

around November 2025, when opus 4.5 or gpt 5.1 was released, it was a lot more than “satisfactory”.

it was capable, i instinctively felt like an inflection point had been crossed.

i was surprised when it could come with understandable code, short chunks, proper references to other parts of the codebase and so on.

i started to close my eyes and hoped the monsters would go away.

i chose to stay in my lane. fine with my little dandy hand written code, taking some time to understand enough and ship things out.

though i’d still use llms to explain things i don’t understand or generate code for parts i don’t care about (i’m look at you frontend).

i was being very dismissive about this whole llm spiel taking over hand rolling code at work.

anger

with the increased intelligence, people got a lot more ambitious. they’re trying out loop engineering, ralph loops and running 10 ~ 20 agents at a time.

somehow i got frustrated, i treated this as a hype train that’d die off, because there’s no understanding of the code outputs.

without understanding, how do you build system that scale? what happens when something go wrong? do you just ask “please don’t make a mistake”?

most outputs are slop, people are getting amazed by games the models could one shot, and for me that was never the point of engineering!

the coolness/impressiveness of demos does not translate to production ready application.

if we don’t write code by hand, how do we understand what the model did and if we’re being questioned, how can we answer tradeoffs and design decision without understanding it!

all i see is people tokenmaxxing, burning through subscription without much to show for. a lot of outputs but very little outcomes.

and i was sure that the rate iteration was slow due to cost and training constraints. a model release was every six months and no way it gets cheaper and smarter.

bargaining

and i was flat out totally WRONG.

somehow, out of a sudden now the releases are like every 2-3 months. from gpt 5.5 to gpt 5.6 (sol, astra, terra) to gpt 6 astra. this was within the past six months, and they’re getting better and cheaper with every release!

i can’t deny it’s capabilities anymore and reality was hitting me hard.

and it seemed like the masses value doing without understanding what’s underneath.

i thought maybe somewhere along the lines i could handroll my code, and people will see value in it as it aided with my ability to explain why i wrote what i wrote

however, as the model become more capable, the craft of understanding what you did seems to be crumbling away.

a void is starting to form

depression

this is where i’ve been spending most of my time in, alongside my sidequests.

not in a clinical depression manner, but just profound sadness, and lost of hope of the road ahead.

what’s the role of a software engineer now, when llms can do everything.

the floor moves every 2-3 months, before i even get a chance to adapt, it shifts every time a new model comes out, and i’m forced to adapt again.

with every 0.5 updates, the models keep getting smarter and cheaper and there’s absolutely nothing i can do about it.

side questing was just me escaping and finding other ways to cope with this because the loss of hand rolling code sits too close to me.

long gone the time where i had to be careful prioritising, choosing which projects to build, lost in the webs of the debugging trace, having that satisfaction when you finished a feature or bug and closing all the 50+ tabs.

poof, the satisfaction, joy and the process are all gone now.

llms can do everything faster, more and a lot more. it can output, output, output while being limited by my bandwidth and big picture view.

acceptance

when all hope is lost, why didn’t i sink further?

because i saw what others were creating with llms on x and i felt i was missing something.

i saw this: What I believe in the future of software engineering by thorsten.

he offers a completely opposite view towards how llms are reshaping the industry. in the past i would have denied it, but having seen what his team has done and knowing the technical depth he has further intrigues me to thinking: “if he is of such a view, what am i missing?”

his views, invites me to slowly tear down my old assumptions, gently restructure my understanding towards software engineering in the age of llms and help me see what’s the road ahead. being the pathfinder in this chaotic environment.

a few days later, i got an interview with a company and knowing how to not write any code and using llms to do it for you was a requirement. i was shocked, because i didn’t expect them to be so ai-pilled.

what i understood was that they’ve a basic scaffolding of a software factory, such as this one https://newsletter.pragmaticengineer.com/p/openai-software-factory

also, i was told that i could be more efficient in my agent use because i was mentioned that i reviewed code through prs and writing out the base code (when starting out from scratch) and manually editing some parts of the code

this made me realised, the ship has sailed for writing code in a work setting. it’s deemed “unproductive” already.

with the interview concluded, even though i didn’t get the job, but i walked away with the experience that “damn, this software factory thing is really happening. huh?” it’s one thing to keep seeing it on twitter, it’s another hearing it from a big company on the ground.

a few days later i read this: https://x.com/davekiss/status/2103613472743342209 (A eulogy for the software engineer), and OOMPH. i say what a well written eulogy for software engineers. go ahead and read it yourself.

it’s the final piece that helped me gained acceptance to what’s going on, making me realise i was grieving.

on the other side, we’re still engineers but the way we contribute is no longer via hand rolling code or clean code, rather it’s using our pen and paper to come up with system design, figuring out what customer wants and using llms to learn and better ourselves.

a breather

these are the five stages for me. but i just hope that others reading this take some time to gain acceptance that the genie is out of the bottle, and we need to find ways to co-exists with it not by denying it, and rejecting it’s capabilities but spend some time to understand it and try to integrate it to your workflow.

lastly, watching this video: https://x.com/HackMIT/status/2101526639834263884, helped me understand how engineers functions at work and off work between the old and new world.

it also showed me the line between “learn to build” or “build to learn”. and we have to be intentional now.

the old world

as swe, we pride ourselves in having depth of understanding, and being able to defend our choices when it comes under scrutiny. and because writing code is so obscure, it’s part of the reason why we are paid well, on top of both of learning AND building for the job.

which means we can rabbit hole till we’re “satisfied” and report back. and the time taken is a non questionable, because “oh it just takes that long”

the new world

moving forward, we’ve to be more intentional about “learning to build” or “building to learn”.

because the former (“learning to build”) is what is valued at work, where we only learn what’s required for the incoming feature / task / project and then we stop, we don’t rabbit hole.

heck in the case of agents, we probably don’t even need to do this much because “we no longer need to understand to build”

whereas the latter (“building to learn”) is what we value personally as software engineers, we like to take the time to rabbit hole and figure things out deeply and be certain about what we’re going to do next, and handle incoming questions if needed and for a long time (pre-llms), the lines between these two modes is a blur because to ship something it required us to understand deeply, and more importantly we’re getting paid to learn how wonderful! but now that llms are here, this is no longer the case.

we have the ability to ship things we don’t understand fully. and if we make the case of “i want to understand before i ship” people will just frown at you :(

we are now paid to only need to understand the bare minimium of code, some ideas of the system and ship it. and we have to live with it.

building to understand, hand rolling code to wrap our head around a concept is now a private and personal time thing, no longer on the company dime.

parting

i feel better, now. i hope other who read this realises, hey you’re not alone. there’s a reason why the whole coding is dead thing with llms is causing such a big divide in the software industry. it’s such a huge part of identity that we’ve loss. and you should take some time to mourn the loss of it. it’ll never be the same again.

with laying out the 5 stages, it’s nothing new. but i hope that with a written example. it’s a reminder or insight to where you are and figure ways out to deal with it.

what’s next? i’ve some idea, but nothing is certain. i’ll probably continue exploring my hardware engineering stuff, maybe fine tune some slms or even step away from the industry as a whole and do personal training. but who knows what the future might hold. all i just hope is for people not to waste their energy resenting a reality that can’t be changed instead look at your feet and move one step at a time :)

If you like these posts, get new ones emailed to you