For most of software history, productivity meant one thing:
Write more code, faster.
That equation made sense when code was scarce and tools were limited.
It doesn’t anymore.
In an AI-augmented world, the highest leverage doesn’t come from producing more code. It comes from deciding what should exist, what should be automated, and what should never be built at all.
Writing less code is not laziness. It’s strategy.
Why “More Code” Is No Longer the Right Metric
AI has collapsed the cost of implementation.
You can:
- scaffold systems in minutes
- generate boilerplate instantly
- refactor at scale
- explore alternatives quickly
When implementation is cheap, code volume stops being a signal of progress.
The new bottlenecks are:
- unclear intent
- weak system boundaries
- missing constraints
- poor workflows
More code doesn’t fix these. Better design does.
Principle 1: Optimize for Outcomes, Not Artifacts
Users don’t care how much code you wrote.
They care whether:
- the workflow is simpler
- the system is reliable
- the result is predictable
- the friction is gone
If a problem can be solved by:
- removing a step
- changing a default
- automating a handoff
- redefining a boundary
Then writing code is often the least effective option.
Good engineering removes work before it adds logic.
Principle 2: Move Decisions Upstream
The earlier you make a good decision, the less code you need downstream.
High-leverage developers spend more time on:
- problem framing
- constraints and trade-offs
- defining “good enough”
- specifying failure modes
This turns many would-be features into:
- configuration
- policy
- automation rules
- or “not needed”
That’s how code disappears without functionality being lost.
Principle 3: Separate Judgment from Execution
Not all work deserves automation. But a lot of it does.
I draw a hard line:
- Execution (deterministic, repetitive, reversible) → automate aggressively
- Judgment (trade-offs, architecture, risk) → keep human
When you respect this boundary:
- pipelines get simpler
- reviews get shorter
- changes get safer
- and codebases get smaller
The system does the work. You keep the decisions.
Principle 4: Prefer Composition Over Construction
Modern development is less about building everything from scratch and more about composing capabilities.
That means:
- assembling services instead of re-implementing them
- configuring behavior instead of hardcoding it
- orchestrating workflows instead of scripting steps
Composition reduces:
- code surface area
- maintenance cost
- failure modes
- cognitive load
And it increases:
- flexibility
- testability
- replaceability
Less code. More control.
Principle 5: Make Defaults Do the Heavy Lifting
Most systems are shaped by their defaults.
If defaults are good:
- users make fewer decisions
- workflows stay consistent
- edge cases shrink
- special-case code disappears
Investing in better defaults often removes entire classes of logic.
This is invisible work. It’s also some of the highest leverage work you can do.
Principle 6: Use AI to Eliminate, Not Multiply
AI can generate code endlessly.
That’s not the point.
The best use of AI is to:
- challenge whether a feature is necessary
- surface simpler designs
- propose deletions and consolidations
- replace bespoke logic with general rules
- stress-test complexity before you ship it
If AI is helping you write more code, pause.
If it’s helping you need less code, you’re using it well.
Principle 7: Treat Deletion as a Feature
Every line of code is:
- something to maintain
- something to test
- something to debug
- something to explain
High-performing teams celebrate:
- removing layers
- collapsing abstractions
- deleting dead paths
- simplifying flows
If your system is growing but your codebase isn’t, you’re doing something right.
What “Doing More” Actually Means
Doing more is not:
- shipping more features
- increasing commit counts
- expanding the codebase
Doing more means:
- reducing user friction
- increasing system reliability
- speeding up change safely
- lowering cognitive load
- making outcomes predictable
Often, the fastest way to get there is to write nothing at all and redesign the system instead.
The Common Trap
Many developers add AI to the same workflow and end up:
- producing more code faster
- increasing surface area
- creating more things to own
- and accelerating complexity
That feels productive.
It isn’t.
Leverage comes from changing the shape of the work, not just the speed of execution.
The Real Takeaway
The future of development isn’t about typing less.
It’s about needing less to be typed.
Great developers don’t prove their value by how much code they produce.
They prove it by:
- how much complexity they remove
- how much friction they eliminate
- how calmly their systems evolve
- and how few moving parts are required to get real outcomes
Write less code.
Do more of what actually matters.
Top comments (1)
Do more of what actually matters.