For decades, the bottleneck in software development was writing code. It was slow, expensive, and required specialized skills. Everything else — planning, coordination, documentation — existed to make coding more efficient.
AI removed that bottleneck. Code generation is fast now. Iteration is cheap.
But most teams are still running processes designed for the old constraint. They're optimizing for a bottleneck that no longer exists.
The Old Constraint Shaped Everything
When writing code was expensive, it made sense to:
**Plan extensively.** Getting requirements wrong meant weeks of wasted coding. Better to invest days in planning than weeks in rework.
**Coordinate carefully.** Multiple coders working on the same system needed synchronization. Daily standups, sprint planning, detailed tickets — all coordination mechanisms.
**Estimate precisely.** Stakeholders needed to know what would ship when. Since coding was the slow part, estimating coding time told you something useful.
**Document afterward.** Documentation was secondary to shipping. You'd document after, if there was time.
These practices were rational responses to the constraint. The constraint was writing code.
The New Constraint
AI made writing code cheap. What's expensive now?
**Understanding.** You can generate vast amounts of code quickly. Understanding what you've generated — why it works, how it fits together, what assumptions it embeds — that's slow.
**Context.** Every decision has context: why this approach, what alternatives were considered, what risks were accepted. That context evaporates quickly. Preserving it is work.
**Judgment.** AI generates plausible output. Evaluating whether that output is correct, appropriate, and aligned with intent — that's human work that takes time.
**Coherence.** When anyone can generate anything quickly, keeping a system coherent becomes harder. Different AI sessions don't share context. Different team members make different assumptions.
The bottleneck is no longer "can we build it?" It's "do we understand what we built?"
The Process Mismatch
Here's the problem: most teams are still running processes optimized for slow coding.
**They still estimate in story points.** But when AI can generate unlimited output, story points measure nothing meaningful.
**They still hold extensive planning sessions.** But when iteration is cheap, planning becomes speculation about something you could just try.
**They still coordinate for large teams.** But when two people with AI can do what ten people did before, the coordination overhead becomes the bottleneck.
**They still document afterward.** But when decisions happen at AI speed, "afterward" means the context is already gone.
The process made sense for the old constraint. It doesn't match the new one.
What Matching Looks Like
If context retention is the bottleneck, your process should optimize for context retention:
**Document in real-time.** Don't wait until after shipping. Capture decisions, intent, and reasoning as work happens, while context is fresh.
**Reduce coordination overhead.** Small teams need less synchronization. Replace ceremonies with async communication where possible.
**Measure understanding, not velocity.** Can team members explain why the system works this way? Can new people ramp up from documentation? That matters more than points completed.
**Version your prompts.** Prompts encode thinking. They're intellectual property. Manage them with the same rigor as code.
**Connect artifacts.** Decisions link to intent. Intent links to evidence. The record is connected, not scattered.
The Transition Is Hard
Moving from code-bottleneck process to context-bottleneck process isn't instant.
The old process has inertia. Tools enforce it. People expect it. "That's how we do things."
But the cost of mismatch is real. Teams spinning cycles in overhead. Important context evaporating. Systems nobody understands. Knowledge walking out the door with departing team members.
The teams that figure this out will have significant advantages. The rest will keep optimizing for a bottleneck that moved years ago.
Start Here
Look at your current process. For each element, ask:
- What problem was this designed to solve?
- Does that problem still exist at the same scale?
- Is this practice still earning its cost?
Be honest. Most teams carry significant unjustified overhead.
Then ask: what would I do differently if I were optimizing for context retention?
The answer points toward your new process.