Strategic vs Tactical Programming
The agent now does the typing. The distinction that decides whether that helps you or buries you — and why your job moved up a level
Two ways to write the same code
John Ousterhout, in A Philosophy of Software Design, draws one line that organizes almost everything else. Two people can produce code that passes the same tests today, yet be playing completely different games.
The goal is the feature, now. You take the shortcut, add the special case, skip the abstraction. It works — and each shortcut drops a little complexity into the system.
The goal is a good design that also works. You spend a little extra now — a cleaner interface, one less special case — so the next change is cheap. The code that ships looks similar. What you were optimizing for does not.
Tactical programming optimizes for this change. Strategic programming optimizes for every change after it. The difference does not show up today — it shows up the tenth time you touch the file.
Why "just make it work" quietly loses
The trap is that tactical programming feels faster, because it is — for the first few changes. Ousterhout's key observation is that complexity is incremental: no single shortcut is a disaster, so there is never a moment where stopping to do it right feels justified. The mess arrives the way debt does — one reasonable-looking decision at a time, until the system is hard to change and nobody can point to the day it happened.
Ousterhout's name for the developer who ships features fastest and leaves wreckage behind — code everyone else has to work around later. Management often rewards them, because the cost lands months downstream and on other people. Speed you can see; the complexity tax you pay later you cannot. Naming the pattern is half of resisting it.
The fix is not a heroic rewrite. It is small, constant investment: Ousterhout estimates spending about 10–20% of your time on design — and argues it pays for itself quickly, because clean code is faster to change and the savings compound. Strategic investment is the opposite of a shortcut: you pay once, the shortcut charges rent forever.
What changed: the agent took the tactical work
Here is why this is the organizing frame for everything in this dojo. Writing the function, fixing the bug, churning out the next endpoint — the tactical layer — is exactly what an AI coding agent is now good at. In Claude Code, the model can produce working code faster than you can type it. The tactical tornado used to be a person. Now it is on tap, for everyone, on demand.
If the agent handles "get it working," the part that is still yours is "get it right": what to build, where the boundaries go, which interface the next change will be cheap against, whether the thing it just wrote is actually a good design. That is the strategic layer — and it is the one AI is weakest at, because it depends on judgment and on context the model does not have.
So the distinction does not just survive AI — it becomes your job description. You have been promoted from the one who writes tactically to the one who directs strategically. As the mission of this workspace puts it: your skills are the ceiling on what the AI can do for you.
Directing strategically: four moves
Strategic programming when an agent does the typing is not abstract. It is four concrete habits, each one a place where your judgment beats the model's speed.
An agent will happily build the wrong thing perfectly. Scoping the task — the feature, the boundary, the thing you are deliberately not doing yet — is strategic work the model cannot do for you, because it does not own the goal.
Ask for a deep module: a simple interface hiding real work behind it. A clean seam is what lets a cheaper, dumber model do good work inside the file later — and lets you swap the implementation without touching everything that calls it.
The agent optimizes for passing the test — that is tactical by default. Your review is where strategy enters: is this a special case that should not exist? Does this name lie? Will the next change be easy? Catching creeping complexity is your move, not its.
Clear interfaces, tests that catch regressions, docs that state intent — these make every future agent run cheaper and safer. You are not just shipping a feature; you are shaping the environment the next ten agent runs happen in.
The frame to carry through the whole course
Every other lesson here is, underneath, a piece of strategic work: reading an error methodically instead of guessing, using git's undo ladder so you can let an agent experiment without fear, deciding whether a task is away-from-keyboard or human-in-the-loop, turning a repeated workflow into a reusable procedure. None of those are about typing code faster. They are about directing the typing well.
"AI ate tactical work" is the useful exaggeration, not the literal truth. Agents still get tactical work wrong — that is exactly why review (move 3) is non-negotiable. The point is not that you never look at code; it is that churning out the first draft is no longer where your leverage lives. Your leverage moved to strategy. Spend it there.
So the next time you open Claude Code, notice which game you are playing. "Just make it work" is now the cheap part — the agent's part. The expensive, valuable, durable part is the strategy around it. That is your job now. Play the strategic game.
Strategy check
Three situations. Spot the strategic move.
A codebase that everyone agrees is "a mess to change" got that way without any single catastrophic commit.
What best explains how it got messy?
An AI coding agent can now write working code faster than you can type it.
Where does that put your leverage?
The agent's change passes every test, but it works by adding a special case that handles one odd input differently from all the others.
The strategic move is to —
On your next Claude Code task, before you let it write anything, spend two minutes on strategy: name what you're building, name what you're not, and sketch the interface you want behind it. Then let the agent do the tactical part. You just played the game that's actually yours.