Lift and Leap: Two Modes of Agentic Engineering
I see two kinds of AI productivity stories: the 10–100x engineer, and the 1.5–2x team. The first kind gets a lot of attention: One engineer and a fleet of agents creates something in a few days. The second kind barely gets noticed: A whole engineering org ships a little faster, every week.
Both are real, and I’ve seen them up close. I built the 1.5–2x kind at my previous company, then watched as we tried to push everyone to go 10x. It didn’t go well.
Here’s what I took away: These are two different modes. They create different kinds of value, and they need different operating models. Confuse them and things break.
I call them Lift and Leap (naming is hard).
Leap: the 10–100x Mode
Leap is two or three engineers, working with coding agents, and a big boulder: a project with real business value that seems so large and complicated, it’s hard to start.
Every org has a few of these. The new product everyone agrees matters. The feature that keeps slipping another quarter. These projects are full of unknowns, and unknowns create friction. Teams fall into analysis paralysis, and the project stalls or quietly dies in planning.
A Leap doesn’t plan the unknowns away. It substitutes much of the deliberate thinking and planning with exploration. A couple people get a set of outcomes and a rough plan, following how I approach software development. They build thin, functional slices. Every one or two weeks there’s a milestone others can see and react to. They don’t wait on decisions. The outcomes are the decision, and almost everything else can be reversed based on feedback. They don’t wait on cross-team dependencies. They do the work themselves, guided by stewards from other teams.
Leap benefits from good platform building blocks, high-leverage services, and documented UI patterns and components. These reduce the number of decisions, and allow the team to focus on the work itself. Keeping the team small reduces the communication overhead.
Trap: Treating Leap as a job for 10x engineers. Leap describes projects, not people. Any engineer can attempt one when the project fits.
Leap’s value is a jump start on a project you thought was impossible, or not worth the time and effort. It proves the project is achievable. More than that, it proves you can make progress on it in iterations, using approaches that once seemed off limits. Think of it as a hackathon mentality applied to real projects: the same speed and freedom to try, but with production quality and someone who follows through.
Lift: the 1.5–2x Mode
Lift is the whole org moving faster than it used to, at a pace it can sustain. It’s less dramatic, and it’s the more common outcome. You can’t sprint all the time. Most of the time, you just need to move faster than you did before. As with any mode, speed only becomes business results when you make good choices about what customers need.
Lift isn’t automatic. Unless you redesign how work flows, the extra output ends up stalled in a different part of the process. Usually that’s review, planning, design, or decisions. That redesign is what my Field Guide is about.
When Lift works, the value is time-to-market. A revenue feature that took six months ships in three. That’s an extra quarter of revenue and a faster feedback loop. Across every team, quarter after quarter, it compounds.
We built a Lift model at my previous company. We saw a 2x baseline on committed milestones, with migrations and refactors compressing much further. We also saw a lot more experimentation, and appetite for work we would have avoided before. It worked.
The Field Guide’s Delivery and Experimentation chapter has the details.
When Leap Becomes the Operating Model
Then leadership saw the Leap-type stories, from both the industry and our own internal wins, and wanted that everywhere. Engineering was reorganized into pods of two or three people. Each pod took on a new project every week or two. Leap became the default way of working.
Work quality suffered. Morale dropped. It imploded.
Looking back, the reasons are clear:
- Nobody owned a domain. Without teams owning specific domains, we lost the core knowledge required to maintain the work. We tried using catch-all guilds, but they were overloaded.
- Nothing was finished. With a new project every week or two, nothing got hardened or maintained. Starting is cheap with agents. Finishing still takes time and effort.
- Upstream couldn’t keep up. Product and design decisions became the bottleneck. Pods either stalled or guessed.
- People paid the cost. Leap is intense. Run without a break, it isn’t a sprint anymore. It’s burnout.
- Lift disappeared. Nobody owned the steady improvement of the existing product, and that’s where most of the revenue was.
The mistake was treating a mode built for exceptions as the operating model for everything.
Running Both: Leap on Top of Lift
At my current company, I’m trying both on purpose. The engineering org runs in Lift, and we add deliberate Leap projects on top.
| Lift | Leap | |
|---|---|---|
| Who | Every team | Two or three people, temporarily |
| Gain | 1.5–2x, sustained | 10–100x, on one project |
| Approach | Steady flow through a well-tuned process | Fast, reversible exploration over up-front planning |
| Work | Ongoing product work | Big boulders: valuable projects that are hard to start |
| Value | Time-to-market | A jump start on work that seemed impossible |
| Constraint | Review and upstream decisions | Outcomes, a driver, momentum |
| Measure | Cycle time and flow | Did it ship, and did it hold up |
The guardrails I’m using:
- Keep Leap rare and temporary. A Leap is a project, not a team or a permanent title. Time-box it to weeks, not quarters. When it’s done, people rest, tidy up the code, and return to their teams. Most of the org stays in Lift.
- Start with outcomes, not a plan. A Leap needs a clear goal, an end-to-end driver, a finish line, and a 1–2 week demo cadence. Not a spec. Replace up-front deliberation with fast, reversible exploration.
- Optimize for momentum, not sign-off. Give the team authority to decide and build across boundaries without waiting on other teams. Make progress visible so others can course-correct post-hoc rather than gatekeep up front.
- Don’t break Lift. Keep
mainshippable, work behind feature flags, and ship small slices. Never dump thousand-line diffs on a Lift team’s reviewers. - Feed the learning back. The patterns, review loops, and agent harnesses discovered during a Leap should flow back into Lift teams.
It’s an Experiment
All of this is an experiment. We’ll try things, and we’ll learn.
We’re in an industry shift, and shifts like this need new ideas. The internet, mobile, and continuous delivery were shifts like this too. Each one needed new ways of working. That’s where Agile, Scrum, Kanban, and the rest came from.
So what’s the new way of working for agentic engineering? Nobody knows yet. Lift and Leap is one of my working answers. Disposable versus durable code is another, and I’ll write about that next.