vs. Shape Up

Shape Up is the closest ancestor to LDD. If you've read Ryan Singer's work, much of LDD will feel like a natural evolution. The framing phase descends directly from shaping. The learning horizon is an evolution of appetite. The emphasis on variable scope over fixed scope is inherited wholesale.

But Shape Up was designed for a world where a small team of humans builds everything. LDD is designed for a world where agents build most of it and the scarce resource is learning, not execution.

What LDD inherits

Shape Up got several things right that most approaches still miss.

Shaping before building

The idea that someone should think carefully about what to build before handing it to a team is obvious in retrospect, but Scrum skipped it entirely. Shape Up introduced shaping as a first-class activity. LDD keeps this as the Frame phase.

Appetite over estimates

Instead of asking "how long will this take?" Shape Up asks "how much time is this worth?" LDD evolves this into the learning horizon: not how much time the feature deserves, but how long it will take to close the learning loop.

Variable scope, fixed time

The insight that scope should flex to fit a timebox, rather than the other way around, is one of Shape Up's best ideas. LDD keeps the spirit but changes the fixed dimension: instead of fixed time with variable scope, it's fixed learning (one bet, one answer) with variable everything else.

No backlog

Shape Up's argument against backlogs is compelling: a pile of unvetted ideas creates false obligations and stale context. LDD agrees. There are bets to place, rather than tickets to burn down.

Where LDD diverges

Fixed cycles don't fit

Shape Up uses six-week cycles with a two-week cooldown. This was a reasonable rhythm for human teams building features. But when agents can build in hours, a six-week cycle is a container looking for something to fill it. LDD drops fixed cycles entirely. The learning horizon determines the timescale.

Shaping is too heavy

Shape Up's shaping process produces detailed pitches with fat-marker sketches, boundaries, and rabbit holes. This level of detail made sense when you were handing off to a team that would spend six weeks building it. When an agent can build a first version in an afternoon, that level of upfront detail is overinvestment. LDD's framing is lighter: a bet with its hypothesis, success criteria, learning horizon, and enough context for agents and humans to act.

No validation built in

Shape Up's cycle ends at shipping. The team builds, ships, and moves on. There's no structured moment for asking "did this work? did users care?" Learning happens informally, if at all. LDD adds Validate and Decide as explicit phases. The loop isn't complete until you have evidence and a decision.

Not agent-native

Shape Up assumes humans do the building, the designing, and the deciding. Agents don't appear in the model. LDD is designed from the ground up for a world where agents are execution partners: specs double as context for agents, build cycles are measured in hours, and rebuilding from scratch is a legitimate option.

"Build big, show little" wasn't possible

In Shape Up's world, building was expensive enough that you wouldn't build more than the scope allowed. In LDD's world, you might build the whole feature and expose one thin slice behind a feature flag. This changes the relationship between scope and delivery entirely.

The emotional difference

Shape Up feels like a team taking a careful bet (in Singer's sense: a commitment to a 6-week cycle). You shape the pitch, you commit to the cycle, you build with discipline, you ship. It's structured and intentional.

LDD uses the word "bet" at a finer grain: a loop-sized commitment that you will double down on, pivot, or abandon after validation. You frame the bet, you test its hypothesis as fast as you can, you look at the evidence, you decide. The tempo is faster, the commitments are smaller, and throwing away work is expected rather than unusual.