What you license · 03
The Increment Delivery Chain
Fifteen agentic skills, built on Anthropic’s Claude, operate the Delivery OS as three movements on one spine: the Chain defines work from objective to plan, the Rhythm operates the quarter, and the Watch reads the portfolio every morning. The business side joins through four more, so the chain runs end to end from business intent to confirmed business outcome.
Every skill runs on your own PDLC guidance, your Delivery OS data, and your context files rather than generic knowledge. Every skill facilitates the way a strong practitioner would: it reads the live portfolio beforehand, arrives with the evidence assembled, runs the session as rounds rather than forms, and leaves the decision with the accountable human. Every facilitation skill also carries a property decision round, so the judgments a session produces land in the Delivery OS schema at the moment they are made, with provenance stamped as a side effect. Every one of the fifteen is built, used in production, and refined through many revisions.
fifteen skills today · every one built, used, and refined in production · decisions stay human
Governed once
The agents assemble the evidence, draft the next action, and stop. Named humans decide.
Every capability on both sides runs under the same rule. One monitor watches the portfolio across Notion, Linear, and GitHub, reads everything, and writes nothing. From that single watch come the reads: the Portfolio Manager’s daily read, each business line’s window into its own work, and the leadership read on the Bridge. All of them compute from the same records against one shared set of thresholds, so everyone acts on the same truth. Any write-back to the system lands only on approval, batched and visible. Nothing in your systems changes silently.
The result
Weeks of senior people’s time, completed in an afternoon, with every decision held by a person.
In one working session the chain took a real increment from a hardened brief to twenty-four fully specified features, one hundred and seven sized stories loaded directly into Linear, and a dated six-iteration plan with its risks named honestly.
Work arrives ready instead of vague, the questions only the business can answer get answered while the work can still change, expert knowledge stays attached to the work instead of leaving with the meeting that surfaced it, and the hours senior people spend assembling status and re-explaining priorities return to delivery, because the system carries that load.
-
Initiative Definition
Turns a strategic objective into an approval-ready initiative: the increments, the dependency map, the case narrative, the hard executive questions answered, and the kill criteria named. Initiatives arrive built to survive scrutiny in one facilitated engagement instead of weeks of drafting and rework.
- Input
- a strategic objective and intent statement, or an existing business case to mine
- Output
- an approval-ready initiative page with its value and innovation increments, dependency map, and governance model
“create an initiative”“decompose this initiative into increments”
-
Increment Discovery
Facilitates an identified increment through the Discovery Workflow to the Definition of Ready: measurable outcomes, Gherkin acceptance criteria, feature decomposition, dependencies, risks, sizing and scoring, and the operational impact section. It accepts an existing PRD and produces the value-first increment from it.
- Input
- an identified increment, or a PRD or project brief to mine
- Output
- an increment document meeting the Definition of Ready, eligible for the intake queue
“run discovery on this increment”“convert this PRD into an increment”
-
Feature Generation
Decomposes an increment into sprint-ready feature specifications with Gherkin acceptance criteria, data requirements, measurable non-functional requirements, and operational notes, then reconciles the parent increment with everything the feature work taught. The standard applies mechanically for every owner, so specification quality stops depending on who runs the session.
- Input
- the increment page
- Output
- feature specifications at Definition of Ready quality plus the updated parent increment
“turn this increment into features”
-
Story Generation
Turns the feature specifications into sized user and technical stories with Gherkin acceptance criteria and cross-story dependencies, packaged for direct Linear import. Corrections the story work surfaces flow back up to the features, so the hierarchy stays true as it deepens.
- Input
- the feature specifications
- Output
- a sized story backlog, an import file that loads cleanly into Linear, and a readable companion
“create stories for these features”“build the story backlog”
-
Value Flow Planning
Runs the Feature Tetris: critical stories first from the risk ordering, features fitted across iterations against real capacity, and a range-with-confidence forecast instead of a date dressed as a promise. The team leaves Inception with an implementation plan whose hot spots and pressure valves are named honestly.
- Input
- the features, sized stories, and the increment’s gates and hard dates
- Output
- the implementation plan event record plus a Notion timeline import
“run Value Flow Planning”“build the implementation plan”
-
Context Files
Builds and evolves the organizational and product-line context files through facilitated expert interviewing, turning what lives in people’s heads into a versioned asset every skill loads by scope. This layer is what makes every output real for your organization instead of a generic internet answer, and an afternoon of interviews pays back on every session after.
- Input
- the domain knowledge of your own experts, drawn out in a facilitated session
- Output
- versioned organizational and product-line context files consumed by the whole chain
“create our organizational context file”“build the context file for this product line”
-
Portfolio Ordering
Runs the recurring ordering work of the portfolio backlog: the monthly refinement session, pre-planning preparation with intake queue re-verification, and ad-hoc reorders when material change lands. The backlog stays ordered on evidence rather than influence, aging increments get real verdicts, and unresolved conflicts go up as escalation memos that arrive answering leadership’s actual questions.
- Input
- the Delivery OS backlog records and the portfolio flow metrics
- Output
- the session record, the reviewed ordering write-backs, escalation memos, and the realization chase list
“run portfolio backlog refinement”“prepare the backlog for VDP”
-
Product Roadmap
Builds and refreshes the roadmap as views over the same records the backlog orders, and runs the pre-planning divergence read reconciling what was planned against what is actually ready. The roadmap stays honest, committed, planned, projected, never uniform certainty, and every divergence becomes a decision before the planning event instead of a surprise during it.
- Input
- the increment records, the latest ordering session, and each planning event’s outcomes
- Output
- live Notion views, the dated snapshot and timeline import, design-system view graphics, and the divergence read
“build the roadmap”“refresh the roadmap”“run the divergence read”
-
Value Delivery Planning
Runs the quarter’s biggest decision event end to end: the capacity model, pre-event scenario simulation, two half-days of decision-forcing facilitation with every pull and deferral documented, the confidence check that can fail, and the living plan with its monthly updates and mini-planning sessions afterward. The quarter gets committed through visible trade-offs at honest capacity, and each cycle’s captured actuals make the next one smarter.
- Input
- the re-verified intake queue, the divergence read, capacity statements with confidence, and carryover reality from Linear
- Output
- the committed quarterly plan, the trade-off decision log, session records, and the post-event assessment
“run Value Delivery Planning”“simulate the quarter”“run the living plan session”
-
Portfolio Monitor
The Portfolio Manager’s daily read. It reads Notion, Linear, and GitHub live each morning, computes every check from the same records against the one ratified threshold register, and reports only exceptions: evidence, owning role, and a drafted next step ready to send, including the mirror-drift check nothing else in an organization performs. It writes to nothing, ever.
- Input
- the live Delivery OS, Linear, and GitHub, read against the ratified threshold register
- Output
- the daily read, on-demand answers with cited evidence, and the weekly digest
“run the daily read”“portfolio health check”“what’s aging”
-
The Bridge
The live command view for executive leadership and their reports, computed from the same watch: what moved, what stalled, what was committed and why, which outcomes arrived, with the constraint diagnosis and the evidence one question away. It replaces the assembled readout, never the decision.
- Input
- the same records and thresholds as the Portfolio Monitor, cut at leadership altitude
- Output
- the leadership read and the weekly executive summary
-
The Door
Idea intake. Ideas arrive and leave evaluation-ready: the problem, the intended result, and the value case shaped in a facilitated pass with the person who brought the idea, so screening decisions are made on substance rather than on who wrote the best pitch.
- Input
- a rough idea from anyone in the organization
- Output
- an evaluation-ready idea record with its disposition path
-
The Voice
Business read-back and expert knowledge capture. It gives the people funding the outcomes a plain-language read of where their investments stand while the work can still change, and it interviews the experts whose knowledge the system needs, landing what they know in the context files where every other skill can use it.
- Input
- the increment in flight and the experts who hold the knowledge
- Output
- the business read-back and the context-file additions
-
The Window
The business-line portfolio read: the view a business leader opens to see their own slice of the portfolio in their own vocabulary. What was asked for, what was committed, what is moving, and what arrived, without a translation meeting in between.
- Input
- the live Delivery OS, scoped to one business line
- Output
- that line’s read of work in process, the committed plan, the intake queue, and the backlog
-
The Proof
Outcome review. It brings each delivered increment back to its accountable owner with the promised result beside the observed one, records one of four verdicts with the evidence linked, and lands it where the next ordering decision can read it. The Proof is how the loop closes and the portfolio learns from what it delivered.
- Input
- a delivered increment whose measurement window has closed
- Output
- the recorded verdict, evidence linked, feeding the next ordering
See it running
A planning round on the BigBank portfolio.
Value Delivery Planning, one round
Capacity statements with confidence, the pulls and deferrals decided in the room and documented as they happen, and the commitment landing on the board as Committed for Delivery.
What the license contains
The skills, the principles they run under, and the layer that makes them yours.
The fifteen skill packages and their change logs; the operating principles every skill is held to, including the read-only rule for the Watch, the property decision round, and the batched write-back on approval; the context-file practice with its interview guides and file shapes; and the decision-rights table the skills defer to. The skills load your PDLC and your Delivery OS, so they are installed against your live portfolio by Process Mentors as part of the engagement, and they stay yours to run afterward. How the tiers are shaped.