Highest Leverage Points: Plans and Validation

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

At Validation Phase

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

1. Write the spec first — What exactly should this do?
2. Define acceptance criteria — How will we know it’s correct?
3. Identify edge cases — What could go wrong?
4. Review the plan — Does the agent’s approach make sense?

After Agent Execution

1. Read the code — Don’t trust, verify
2. Run the tests — Did it actually work?
3. Check edge cases — Did it handle the hard parts?
4. Validate against spec — Does it do what we asked?
5. 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