In the age of AI agents, software engineers have maximum leverage at two points: planning and validation. Everything in between is increasingly automated.
The New Leverage Map
┌─────────────────────────────────────────────────────────────┐
│ │
│ PLANNING EXECUTION VALIDATION │
│ ████████████ ░░░░░░░░░░ ████████████ │
│ Human leverage Agent territory Human leverage │
│ │
└─────────────────────────────────────────────────────────────┘
The middle is commoditized. The edges are where you win.
Why Planning Is High Leverage
1. Plans Shape Everything Downstream
A 10-minute planning decision affects 10 hours of execution.
Good plan → Agent executes correctly → Working code
Bad plan → Agent executes correctly → Wrong code
The agent will faithfully implement whatever you specify. If the spec is wrong, the implementation is wrong—no matter how well it’s executed.
2. Humans Have Context Agents Lack
- Business constraints
- User psychology
- Technical debt history
- Team dynamics
- Regulatory requirements
- Strategic direction
Agents see code. Humans see the system the code lives in.
3. Planning Is Where You Prevent Problems
Cost to fix at planning: 1x
Cost to fix at coding: 10x
Cost to fix at production: 100x
Every minute spent planning saves hours of rework.
Why Validation Is High Leverage
1. Agents Are Confidently Wrong
LLMs generate plausible output. Plausible ≠ correct.
Agent: "I've implemented the authentication flow."
Reality:
- Works for happy path
- Fails on edge cases
- Has subtle security flaw
- Doesn't match the spec
Validation catches what execution misses.
2. Tests Are Specifications
When you write or review tests, you’re defining truth:
// This test IS the specification
it('should reject expired tokens', () => {
const expired = createToken({ exp: Date.now() - 1000 });
expect(() => validate(expired)).toThrow('Token expired');
});
If the test is wrong, the code will be wrong. Tests are high-leverage planning artifacts.
3. Validation Is Compound
Good validation infrastructure pays dividends forever:
Session 1: Write thorough tests
Session 2: Agent runs tests, catches own mistakes
Session 3: Agent runs tests, catches own mistakes
Session N: Tests still protecting quality
Every test you write amplifies all future agent work.
The Execution Gap
Why is execution low leverage?
Agents Are Good Enough
For most implementation tasks, agents produce acceptable code:
- CRUD operations
- API integrations
- UI components
- Data transformations
- Boilerplate
The gap between human and agent execution is narrowing.
Execution Is Recoverable
Bad execution can be fixed:
- Run tests → see failures → fix
- Run linter → see issues → fix
- Run type checker → see errors → fix
Bad planning is harder to recover from:
- Wrong architecture → rewrite
- Wrong abstraction → refactor everything
- Wrong feature → wasted work
High-Leverage Activities
At Planning Phase
| Activity | Leverage |
|---|---|
| Defining the problem correctly | Extreme |
| Choosing the right abstraction | High |
| Identifying edge cases upfront | High |
| Setting acceptance criteria | High |
| Reviewing agent’s proposed plan | High |
| Specifying non-functional requirements | Medium |
At Validation Phase
| Activity | Leverage |
|---|---|
| Reviewing security implications | Extreme |
| Validating business logic | High |
| Checking edge case handling | High |
| Verifying integration points | High |
| Testing failure modes | High |
| Performance validation | Medium |
The Engineer’s New Role
OLD: Plan → Code → Test → Deploy
████ ████ ████ ████
Human Human Human Human
NEW: Plan → Code → Test → Deploy
████ ░░░░ ████ ░░░░
Human Agent Human Agent
You’re not writing code. You’re:
- Defining what should be built
- Validating that it was built correctly
- Iterating when it wasn’t
Practical Application
Before Agent Execution
- Write the spec first — What exactly should this do?
- Define acceptance criteria — How will we know it’s correct?
- Identify edge cases — What could go wrong?
- Review the plan — Does the agent’s approach make sense?
After Agent Execution
- Read the code — Don’t trust, verify
- Run the tests — Did it actually work?
- Check edge cases — Did it handle the hard parts?
- Validate against spec — Does it do what we asked?
- Security review — Any vulnerabilities introduced?
The Leverage Formula
Total Value = (Plan Quality × Execution Quality × Validation Quality)
Where:
- Plan Quality: 0.1 to 1.0 (human controlled)
- Execution Quality: 0.7 to 0.9 (agent controlled, increasingly good)
- Validation Quality: 0.1 to 1.0 (human controlled)
Bad plan (0.2) × Good execution (0.8) × No validation (0.2) = 0.032
Good plan (0.9) × Good execution (0.8) × Good validation (0.9) = 0.648
20x difference from focusing on the high-leverage points.
Anti-Patterns
Low-Leverage Trap: Micromanaging Execution
❌ "Use a for loop here, not map"
❌ "Name this variable 'userData' not 'data'"
❌ "Put this import at the top"
Agent can figure this out. Focus elsewhere.
Low-Leverage Trap: Skipping Validation
❌ "Agent said it's done, ship it"
❌ "Tests passed, must be correct"
❌ "It works on my machine"
Validation is where you catch the 20% that's wrong.
Key Principle
The highest-paid skill is knowing what to build. The second-highest is knowing if it was built correctly. Everything in between is increasingly automated.
Focus your time on plans and validation. Let agents handle execution.
Related
- Building the Harness – Validation infrastructure
- The Verification Ladder – Progressive validation techniques
- Learning Loops – Encoding validation failures
- Agent Swarm Patterns – Multiple perspectives for validation
- Sub-agents – Specialized validators
- Meta-Questions – Questions that enable validation
- The Meta-Engineer – The identity behind leverage thinking
