AI-era
Product
Development
Life Cycle.
Idea to spec to build, when AI compresses the build half.
Premise
The build half
got faster.
Code generation, scaffolding, refactors, throwaway prototypes — the production half of the cycle compressed by an order of magnitude in two years.
It's the half teams instinctively measure. It's also the half that mattered least.
AI does not remove product judgment — it makes product judgment more load-bearing.
The thesis · § 01
Diagnosis
Most teams added AI to old workflows instead of redesigning the workflow.
Same cycle, faster typing.
Same standups, same tickets, same handoffs — with a copilot stapled to the IDE. Velocity rises. Re-opens rise faster.
Redesign the cycle around judgment.
Reserve human time for framing, options, and validation. Give AI the drafting, clustering, and acceleration. Move the bottleneck on purpose.
The pattern
Idea to spec to build, in seven moves.
- 01FrameOutcome and boundary, before motion.
- 02GatherSignal worth its salt; cluster the rest.
- 03ShapeReal options, with real tradeoffs.
- 04SpecifyDecisions named on the page.
- 05BuildRunnable, not impressive.
- 06ValidateWhat counts as success, decided up front.
- 07LearnKeep, change, or kill — and write it down.
Frame— outcome and boundary.
Most teams skip this. The brief is in someone's head, the doc says "improve onboarding," and seven sprints later nobody remembers what was supposed to be true.
A framing brief is one page. Outcome, boundary, the one thing that would make us kill this in a month.
Gather— signal over noise.
Volume is no longer the constraint. Discrimination is. The team that keeps three transcripts and reads them carefully beats the team that summarizes thirty.
An evidence stack is ranked, attributed, and small. If it's longer than a page, it's not a stack — it's a pile.
Shape— real options, not fake ones.
Three options are only useful if losing each one would change the product. If the team would build the same thing under any of them, you have one option in three coats.
A real option set has a cheapest, a fastest, and the one that actually answers the brief. Often they're the same; sometimes they aren't.
Specify— decisions, not vibes.
A spec earns the word decisioned when every open question has either been answered or marked as deferred — with the deferral cost named.
"We'll figure it out in the build" is not a deferral. It is a re-open scheduled for next month.
Build— runnable, not impressive.
The point of the prototype is to be wrong about something specific, fast. Not to be a small version of the eventual product.
If you can't say what the prototype is testing, the prototype is decoration.
Validate— what counts as success.
Validation written after results is just commentary. The threshold has to be on the page when the prototype ships, or it'll move to fit the data.
Two numbers and a sentence. That's the format. More than that is a hedge.
Learn— keep, change, or kill.
A decision log isn't a retro. It's a list of decisions made — with the framing they were made under — so the next call doesn't start from zero.
If the log isn't searchable in five seconds, nobody searches it. If nobody searches it, you make the same call twice.
SPF.
Sprint planning, recomposed around the framing step.
The first thing I do every Monday is open Jira and try to think about next sprint while the current one is still mid-flight. SPF is what I built when AI made it cheap to draft — and obvious that drafting wasn't the bottleneck.
The frame moved from "what tickets" to "what outcome." Everything downstream got easier.
Celine.
Legal-tech without the swagger; AI in the drafting seat, lawyers in the specify seat.
The whole point was to run the cycle slowly on purpose. Frame, gather, shape — all done by humans. AI did the boring drafting so the lawyer's time landed where it counted: on constraints.
Faster build half. Same — actually higher — judgment density.
Application
Reach for this when teams feel faster but less aligned.
Messy B2B and lightly regulated domains, where the brief mutates and the cost of weak framing compounds.
Teams shipping fast but reopening decisions — the "we already discussed this" Slack thread, twice a week.
Heavily regulated builds where the spec is the regulator. There the cycle is already judgment-dense.
Pure infra with a fixed surface area. AI-acceleration helps; the seven moves are overkill.
Closing
Three numbers I'd watch before velocity.
Spec revision cycles.
How many times the spec changes between sign-off and ship. The number that sneaks up on every team in year two of AI-assisted dev.
Re-opened decisions.
Calls made, then unmade, then made again. Each re-open is a tell that the framing didn't carry.
Build-to-validation latency.
Hours from "runnable" to "we know if it worked." If that's days, the build half got faster and the rest didn't.
Faster building made weak framing more expensive.
That's the whole argument. The seven moves are how I keep the framing alive while letting AI do the parts it's actually good at.