Code as liability, not an asset — from Software Engineering at Google

I’ve been reading Software Engineering at Google, and one line stuck with me:

Code is a liability, not an asset.

If you’re a programmer, that probably sounds wrong. Your code feels like something you built — proof of skill. How could it be a liability?

First, this only makes sense inside software engineering.

In that context, writing code costs time and people, but that alone doesn’t make it an asset. What actually matters is the product problem the code solves and the value it delivers to users and the company.

And once code exists, it has to be maintained and kept running. It isn’t a one-off. How long that lasts depends on the life of the product it serves.

So code has a carrying cost — like debt. Until you pay it down, it keeps demanding investment.

That framing, I think, is what code really is.

Why are there so many methodologies built around code?

Pair programming, code review, style guides, TDD, design doc review, CI/CD, paying down tech debt, and so on.

People in the trenches know these practices protect quality — but is that the whole story?

If you start from “code is a liability,” the picture clears up.

Code must be maintained. Neglect it and it rots like an apple — eventually it’s the legacy everyone hates.

So from day one, plan against the product lifecycle: how long will this code need to live? Design, implement, and plan maintenance with that horizon in mind.

Solid process early produces code that fits the moment and slows the rot from the start.

What matters just as much is that the team treats maintenance as normal — not an afterthought.

You don’t ignore tech debt that’s already broken but unowned just because a new feature ships. Paying debt in small slices through ordinary work beats one desperate payoff at the end.

And when code stops serving the product well, decide when to retire it and clear the liability. Many teams skip that step.

Some say: if we’re not using it anymore, can’t we just leave it? Seems fine.

Then old code still gets imported, old and new services stay tangled, the repo bloats, static checks fail — and guess who gets blamed?

By then it should be obvious: the code is always your liability. If you don’t see that, you end up stuck in the mud.

Can you blame the PM or EM for not scheduling debt cleanup?

Maybe they know, but their incentives lean toward shipping features and iterating the product.

Whether you spot liability early and fold tech debt into everyday delivery — that’s on you.

I used to think software engineering was fuzzy theory next to “real” coding.

Now I still love writing code — but those “fuzzy” disciplines are what separate strong engineers from people who only type.

Questions? Leave a comment below or email: newbvirgil@gmail.com