Article 014: Why experience matters more in async development
Key Message: Judgement becomes more important than speed. Senior intuition compounds in async systems.
Series: C — Tensions & Implications (Part 3 of 5) Publish Date: Monday 2026-04-20
Story Outline
Opening hook
[The assumption that tools level the playing field]
The shift
[Why experience and judgement matter more, not less]
Evidence / Examples
[Examples of senior intuition compounding in async contexts]
Implications
[What this means for teams, hiring, mentorship]
Close
[Where do we leave the reader?]
Notes
[Add notes as you develop the article]
Threads from earlier articles
| From | Theme | Pick up here |
|---|---|---|
| 003 | Abstraction alignment | Experience = recognizing misalignment patterns. Knowing when “yes” doesn’t mean agreement. |
| 003 | Review: sampling or comprehensive? | If sampling: experience = knowing where. If comprehensive: experience = faster pattern recognition. |
| 003 | Context window mismatch | Experience compensates for limited context — you know what to check without seeing everything. |
| 007 | Attention allocation | Experience = better attention allocation. Less wasted attention on low-risk areas. |
Potential angles
- Junior vs senior in async: the gap widens, not narrows
- Pattern recognition as the core skill
- “Knowing what to check” without comprehensive review
- Mentorship challenges: how do you teach intuition?
- The danger of false confidence without experience
- Speed of typing → speed of judgment (what matters shifts)
Note: The deskilling/goalkeeper angle moved to Article 012
The supervision paradox (from Article 006)
Core tension: Supervision is becoming a skill you need earlier in your career, before you’ve had time to develop the judgment it requires.
The traditional progression:
- Junior: Write code, get feedback
- Mid: Write code, review others’ code
- Senior: Less writing, more reviewing and directing
- The supervision role came after years of making mistakes yourself
What’s changed:
- Agents accelerate you into the supervisory role immediately
- Junior developers now supervise agent output from day one
- But supervision requires judgment that comes from experience
- How do you supervise when you haven’t learned the lessons yourself?
The paradox:
- You need to evaluate code quality without having written enough bad code to recognize it
- You need to spot architectural problems without having lived through the consequences
- You need to know what to reject without understanding why it’s wrong
- The agent can execute at senior speed, but you’re evaluating at junior judgment
Implications:
- The junior/senior gap may widen, not narrow
- Agents don’t level the playing field — they amplify the value of experience
- Junior developers may become productive faster (agents execute) but learn slower (less hands-on mistakes)
- The question: can you learn supervision without first learning creation?
- Or does supervision require the scar tissue of having built (and broken) things yourself?
This connects to:
- Article 006: The shift to supervision (naming what’s happening)
- Article 012: Deskilling / maintaining hands-on capability (different aspect of experience)
- Article 015: Why experience matters more (exploring the consequences)
- Article 016: What breaks (the learning/onboarding challenge)