Coinbase reduces time from idea to production by 90% with Cursor · Cursor
Concept 1: The "Agent-First" Model of Software Development
What is it?
Traditional software development = humans write code line by line. Agent-first development = humans define what they want, and AI agents build it.
Think of it like this:
Instead of being a bricklayer, the engineer becomes an architect.
The Key Shift:
| Old Model | Agent-First Model |
|---|---|
| Engineer writes code | Engineer defines intent |
| Engineer reviews every line | Engineer validates results |
| Specialist teams | Full-stack engineers with agents |
Why does this matter?
Coinbase found that legacy processes (not developers) were the real bottleneck. Plugging AI into broken systems doesn't work — you must redesign the system around AI.
Concept 2: Rethinking Sprint Planning
What is traditional sprint planning?
In most engineering teams, work follows this cycle:
- Idea is created
- Ticket is written
- Ticket is prioritized
- Ticket is assigned
- Developer starts working
This introduces days of delay before a single line of code is written.
What Coinbase changed:
With AI agents, developers can:
- Grab tickets as they are created
- Map execution immediately (using "Plan Mode")
- Delegate implementation to agents right away
The Result:
⏱️ Time from idea → first PR: 8 days → under 30 minutes
Key Takeaway:
The goal is speed of value reaching users, not following rigid planning rituals.
Concept 3: Shifting to Higher-Level Abstractions
What does "higher-level abstraction" mean?
Instead of thinking about how to write code, engineers focus on what to build and whether the result is correct.
The Old Engineering Effort:
Write code → Review code → Debug code → Repeat
The New Engineering Effort:
Define requirements → Agent builds → Engineer evaluates outcome
Practical Change at Coinbase:
- Engineers now write product and technical requirements explicitly for agents
- These documents serve two purposes:
- Guide the agent during implementation
- Evaluate the agent's output afterward
Key Takeaway:
Manual line-by-line code review will trend toward zero. Human judgment moves up the stack to architecture and outcomes.
Concept 4: Smaller Teams, Broader Scope
The Old Team Structure:
- Large teams of specialists (frontend, backend, mobile, etc.)
- Each specialist handles only their domain
- Features require coordination across many people
The New Team Structure:
- Small teams of 1-2 engineers
- Engineers act as full-stack generalists
- Agents handle the adjacent technical areas the engineer isn't expert in
How it works in practice:
One engineer runs 5-7 AI agents in parallel, each working on different parts of a project simultaneously — like managing your own team.
The Result:
🏗️ Teams of 1-2 engineers now build features that previously required entire teams.
Concept 5: Change Management — Leading from the Front
The Problem with Top-Down AI Adoption:
Simply telling developers "use AI" produces minimal change.
What Actually Works — 3 Strategies Coinbase Used:
Strategy 1: Lead by Example
The senior director used Cursor daily in front of his team to model the behavior he wanted.
Strategy 2: Identify and Elevate Champions
Find early power users → make them internal teachers → they spread knowledge organically.
Strategy 3: Agent Speedruns
- 30-minute sessions where every developer must ship a PR using AI
- Early runs: 50-70 PRs
- Now regularly: 500+ PRs
Key Takeaway:
"You can't tell people to use AI and expect meaningful change. You have to show them what is possible."
Concept 6: Measuring Outcomes, Not Inputs
The Old Metric (Input-Based):
- Lines of code written
- Number of tickets closed
- Hours worked
Why this is flawed:
Every new line of code is a risk — more code = more bugs, more maintenance, more complexity. Rewarding code volume incentivizes the wrong behavior.
The New Metric (Outcome-Based):
⭐ North Star: Time from idea to production
| Stage | Before | After |
|---|---|---|
| Idea → First PR | 8 days | 30 minutes |
| Idea → Production | 20 days | 1.8 days |
| Long-term target | — | 4 hours |
Key Takeaway:
Focus on what value was delivered to users, not how much work was done.
Concept 7: The "Superbuilder" Role
What is a Superbuilder?
A new engineering role specifically created to increase engineering velocity itself.
What they do:
- Removed from the normal product roadmap
- Focused entirely on internal tooling and automation
- Example: Built a Coinbase coding agent inside Slack so engineers can go from idea → implementation with fewer manual steps
Why this matters:
Instead of everyone slowly getting better at AI, dedicated people accelerate the entire organization's capability.
Summary: The Full Picture
OLD WAY:
Idea → Plan → Assign → Write Code → Review → Debug → Ship
(~20 days)
NEW WAY:
Idea → Define Intent → Agents Build → Engineer Validates → Ship
(~1.8 days)
The 4 Core Principles:
- Redesign systems around AI, don't retrofit AI into broken systems
- Measure outcomes (time to production), not inputs (lines of code)
- Engineers move up from writing code to defining intent and evaluating results
- Change requires demonstration, not just instruction
💡 The biggest mindset shift: The engineer's job is no longer to build software — it's to direct software being built.