A few years ago, something happened that I still remember quite vividly.
Our team had spent a considerable amount of time working on a project. We had built things, solved problems, made decisions, argued over implementation details, and put a fair bit of ourselves into the work.
And then, one day, the project was scrapped.
Not because the engineering was bad. Not because the product didn't work. We simply ran out of budget.
The project was shelved, the repositories were archived, and the code we'd written was no longer going to be used.
I took it surprisingly hard.
For a few days, I genuinely couldn't sleep properly. I kept thinking about the work we'd done. All those hours spent figuring things out, the little design decisions, the problems we'd solved, and the code we'd carefully put together.
It felt like a part of me had gone missing.
Looking back, I realise I was grieving something rather unusual for a software engineer: code.
I had done something that, perhaps, every developer should be careful about doing.
I'd become emotionally attached to my code.
I cared about what I wrote. I wanted it to be used, maintained, extended, and eventually become part of something bigger. I didn't just see it as a collection of files and functions. I saw the effort, thought, and countless little decisions that went into creating it.
And when all of that was archived, it felt like throwing away a little piece of my work and, in some ways, a little piece of myself.
Fast forward to today.
Something has changed.
I've noticed that I'm no longer attached to my code in the same way.
And it's not necessarily because I've become a better or more mature engineer. At least, that's not the explanation I've arrived at.
AI has fundamentally changed the way we're building software.
We're experimenting more. Prototyping more. Generating code at a speed that would have been difficult to imagine a few years ago. Ideas that might once have taken weeks to materialise can now be explored in days, sometimes hours.
And naturally, a lot more gets thrown away.
We try an approach, generate an implementation, evaluate it, decide it isn't quite right, and move on. Sometimes entire chunks of work get discarded. Sometimes a prototype becomes obsolete before we've even had the chance to get emotionally invested in it.
And here's the interesting bit.
I don't feel bad about it anymore.
When AI has generated a significant portion of the code, I don't seem to develop the same emotional attachment to it. If something doesn't work, we change it. If an approach isn't right, we discard it. If the experiment doesn't lead anywhere, we move on.
It can be tedious. It can be frustrating. Sometimes reviewing and correcting generated code is downright annoying.
But I don't feel that same sadness.
Have we lost something along the way?
I wonder if there's a subtle shift happening here that we aren't talking about enough.
For a long time, writing software was an intensely personal activity. You spent hours understanding a problem, thinking through the solution, choosing an abstraction, refining an implementation, and making trade-offs.
You developed an almost instinctive relationship with the codebase.
You knew where things belonged, why certain decisions were made, and which parts needed a little extra care. You had an appreciation for the work, even when nobody else noticed the details.
There was a certain sense of ownership that came from having built something yourself.
Now, with AI, the relationship is becoming different.
We're increasingly directing, reviewing, validating, and orchestrating code rather than personally crafting every part of it.
The output is arriving faster than our ability to become emotionally invested in it.
And perhaps that's a good thing.
After all, code is supposed to solve problems. It isn't supposed to become a personal possession. We should be able to throw away an implementation when a better one comes along. We should be able to experiment without treating every discarded line as wasted effort.
But I can't help wondering whether something else is disappearing in the process.
Perhaps it's not attachment to code itself, but a certain kind of engineering empathy.
That feeling of caring about the implementation, understanding its intricacies, appreciating the effort behind it, and wanting to make it better.
Does that empathy naturally transfer when we're no longer the ones writing most of the code?
Or does it gradually fade when code becomes increasingly cheap to generate and increasingly easy to discard?
I don't have a definitive answer.
Maybe the attachment was never really about the code.
Thinking about that old project, perhaps what bothered me wasn't that the code was no longer being used.
It was that something I'd invested so much of myself in had suddenly become irrelevant.
The code was tangible evidence of the time, thought, and effort we'd put in. Losing the project felt like losing the opportunity for all that effort to mean something.
Today, I'm probably more comfortable with the idea that not everything we build needs to survive.
Some things are experiments. Some things are stepping stones. Some things exist simply to help us understand what we should build next.
And that's okay.
But I do wonder whether, in becoming comfortable with disposable code, we're also becoming a little more detached from the craft of software engineering itself.
Maybe the challenge for developers in the AI era isn't to fall in love with the code again.
It's to find something else worth caring about.
The problem we're solving. The decisions we're making. The quality of the outcome. The people using what we build.
Because code might be increasingly disposable.
But the responsibility for what we build shouldn't be.
Top comments (8)
Funny, for me it started from the other end: writing the code was always the part of the job I liked least. So agents took the bit I'd have handed over first. What they didn't take is in your last line: the code got cheap, the responsibility didn't.
That's an interesting perspective! I guess it comes down to which part of the process we enjoy most. And I completely agree with your last point. We might be delegating more of the actual implementation, but the responsibility for what we ship hasn't gone anywhere. If anything, it probably matters even more now.
The archived-project grief hit home — I still remember a shelved project years ago and the weird feeling that all that work just didn't count anymore. Your question at the end is the right one: if the code is disposable, does the empathy fade with it? I think the attachment just moves — to the problem, the decisions, the outcome. At least that's what I tell myself when I delete a whole AI-generated prototype without blinking.
I think you're right. Perhaps the attachment simply shifts from the code to the problem and the outcome. There's also something liberating about being able to discard an implementation without feeling like you're throwing away weeks of your life. I guess the trick is knowing what is worth holding on to and what isn't.
The budget cancellation and the discarded AI prototype seem to involve different kinds of loss: one removes a project's future, while the other is part of choosing an implementation. I wonder whether that difference explains some of the change in attachment, alongside who wrote the code. Would shelving an AI-heavy project after months of real users and team decisions feel equally disposable? That comparison might help separate attachment to typing from attachment to a shared investment.
That's a very good distinction, and I hadn't quite looked at it that way. I think you're right that losing a project's future is very different from deliberately throwing away an implementation. And to answer your question, I don't think an AI-heavy project with months of real users, decisions and shared investment would feel disposable at all. Perhaps the attachment was never really about who wrote the code, but about everything we invested in making the project meaningful.
I think I felt the same way when a project I loved got shelved.
It's a strange feeling, isn't it? Especially when you've put so much thought, time and effort into something and then suddenly have to let it go. I guess some projects stay with us long after we've stopped working on them.