Ken Thompson has been building some of the most important pieces of computing for more than half a century. Co-creator of Unix, designer of the B language (direct precursor of C) and co-creator of Go, he has left an absolute mark on the creation of software that few can match.

So when he claims that one of his most productive days was when he deleted 1,000 lines of code, it’s worth taking him seriously. He states that writing only what is necessary, eliminating what is left over and leaving the systems simpler than they were is actually more productive.

Who is Ken Thompson and why what he says matters

Thompson began to mark the history of software in the late sixties, when together with Dennis Ritchie he developed Unix at Bell Laboratories. It wasn’t just an operating system, it was a way of understanding computing.

With small, modular tools that do one thing well and combine with others, he adopted a minimal and efficient construction philosophy that accompanied him in each subsequent project.

The B language, which Thompson designed as a successor to BCPL, laid the foundation for Ritchie to develop C, the programming language that for decades was the absolute standard for systems programming.

Decades later, already at Google, Thompson co-created Go, a language intended for large-scale production systems that repeats the same pattern: simplicity over sophistication, clarity over complexity.

Why deleting code can be more valuable than writing it

Every line of code added is also a line that someone has to read, understand, and maintain. It is one more spot where a bug can hide, an extra place that must be covered with tests and an additional piece that complicates future changes.

Therefore, when a system grows without criteria, technical debt silently accumulates until any modification, no matter how small, becomes a risky operation.

It is for this reason that, according to the expert, Deleting code is not going backwards, but rather reducing the error surfacesimplify the architecture and leave the system in a state in which future changes are faster and safer.

This operation requires more judgment than adding new functionality, because it requires understanding the system in depth, identifying what really matters, but also having the judgment to ignore the rest.

The philosophy that Go inherited and that is still necessary

Go was born with that same obsession with clarity compared to languages ​​like C++ or Java, where its syntax is deliberately brief, its type system is direct and its concurrency mechanisms are designed to be understood, not just used.

Thompson and his co-creators applied in Go exactly what the phrase summarizes: that each element that is not in the language is a complexity that the programmer does not have to manage.

That philosophy collides head-on with a real trend in many current development teams, where Productivity is still measured by the amount of written lines of code.