DEV Community

Cover image for I Used to Get Attached to My Code. I Don't Anymore.
ujja
ujja Subscriber

Posted on AI-assisted

I Used to Get Attached to My Code. I Don't Anymore.

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 (0)