The Best Line of Code Is the One You Never Write

The best line of code is the one you never write.

The second best is the one you delete.

This isn’t laziness. It’s restraint.

Every line of code is a liability: something to read, understand, test, debug, maintain, migrate, and eventually explain to someone who didn’t write it, often future you, who will be far less charitable. Less code doesn’t just mean fewer bugs. It means fewer assumptions, fewer hidden contracts, and fewer places for complexity to quietly rot.

Simple code beats clever code almost every time. Clever code impresses in the moment. Simple code survives. The goal isn’t to be smart. It’s to be clear. Code should explain itself without requiring interpretation or bravado.

Consider a small example.

Clever:

total := lo.SumBy(

    lo.Filter(orders, func(o Order) bool {

        return o.Paid && !o.Refunded

    }),

    func(o Order) float64 {

        return o.Amount * (1 - o.Discount)

    },

)

It works. It is concise. It is also doing filtering, business rules, and calculation in a single expression. Understanding it requires knowing the helper library, the order of operations, and the embedded business logic all at once.

Simple:

var total float64



for _, order := range orders {

    if !order.Paid || order.Refunded {

        continue

    }



    total += order.NetAmount()

}

More lines. Less code.

The intent is obvious. The loop reads top to bottom. The business rule has a name. There is a clear place to add logging, debugging, or a new condition without fear.

This is not accidental. Go’s design nudges you toward this style. It makes cleverness slightly uncomfortable and simplicity feel natural, because boring, readable code scales better than impressive code ever will.

The same principle applies at the system level. Well-designed systems outperform clever ones. Clever systems depend on sustained brilliance and discipline to keep functioning. Well-designed systems depend on structure, constraints, and unremarkable correctness. They do not need heroics to stay stable.

AI makes this lesson more urgent, not less. Modern tools are extremely good at generating code quickly and confidently. They will happily produce large, intricate solutions to problems that would have been better solved by a simpler model, a tighter constraint, or a deleted requirement. AI optimizes locally. Humans must optimize globally.

Without global understanding of the domain, the trade-offs, and the long-term cost, code generation turns into code inflation. The risk is not that AI writes bad code. It is that it writes reasonable-looking code that no one fully understands or truly owns.

Great engineers do not win by typing faster. They win by choosing simplicity over cleverness, design over tricks, and deletion over accumulation.

Deletion is a design skill.

Omission is an architectural decision.

In an era where code is cheap, clarity is expensive. That is where real engineering lives.

Write less. Delete more. Design simply.