Why cultivation.
A product is not assembled. It is not shipped from a factory floor. It is cared for over time by people whose attention is finite, in conditions they did not choose, with evidence that arrives unevenly.
The dominant metaphors of software product management are industrial. We have backlogs and pipelines and shipping. We talk about velocity and throughput. The implication is that product work is the conversion of inputs into outputs at a measurable rate, and that the job of a Product Leader is to keep the line moving.
It is not.
Product work is closer to the work of a smallholding than the work of a factory. There is a Soil: the strategic context every decision grows from. There are Seeds: recommendations the team chooses to plant. There is Growth: the built change that emerges, slowly, in unpredictable shapes. There is a Harvest, and a Yield, and a Gleaning afterward of everything the Harvest missed. There is, every cycle, a moment to Turn the Soil.
The work is the same. Only the names change.
Cultivate OS is the operating system for a product team that has stopped pretending the work is industrial.
The four promises.
The whole product is held together by four sentences. They are the load-bearing commitments. If a feature contradicts one of them, the feature does not ship.
Every Seed carries its evidence trail.
Every Harvest has an expected Yield.
Every Harvest produces Gleanings.
Every learning turns the Soil.
No claim without a citation. No launch without a measure. No measure without a return. No learning without a place to land.
What gets named.
Cultivate OS names ten things a product team already does but rarely distinguishes: the difference between an Input (a call transcript) and a Nutrient (a specific, citable fact extracted from that call); between a Seedling (a hypothesis under construction) and a Seed (a recommendation ready to act on); between a Sheaf (the bundle of artefacts a launch needs) and a Harvest (the moment the Sheaf goes out).
The naming is not aesthetic. It exists so that the team's arguments can land in the right place. A debate about whether a Seedling is promotable is not the same as a debate about whether the resulting Seed is the right one to plant first. Conflating those two arguments is the most common cause of a stalled cycle, and the most common cause of a bad feature.
Plain English remains.
The vocabulary is paired. Every branded noun has a plain-English gloss that travels with it: Seeds: recommendations ready to act on. Nutrients: the evidence behind a claim. Sheaf: the bundle of artefacts a launch needs.The branded form lives in the interface and in the team's arguments; the plain form is always one sentence away.
What does not get named.
There is no roadmap. There is no OKR. There is no velocity. These words are not part of the system. Some of the things they refer to are; some are not.
A roadmap is, in this model, a forecast of which Seeds are likely to be planted in the next two cycles. It is a derived view, not an object. Cultivate OS does not store a roadmap. It stores the Seeds and the Soil; the roadmap is what falls out when you ask the Field to tell you what it expects to plant next.
OKRs collapse into Measures. Every Grow Plan sets the Measures the Harvest will be weighed against. Those Measures are the smallest, sharpest version of an OKR worth keeping; the parts of OKRs Cultivate OS does not adopt are the parts that float free of any specific Seed.
Velocity is not a measure. We do not track it. We track Yield.
A cycle is the unit.
Cultivate OS organises product work around the cycle, not around the quarter, the sprint, or the release. A cycle starts when a Field Turns the Soil after a Harvest, and ends when the next Harvest sends Gleanings back into Winnow. Cycles can be days or quarters long; the shape is what matters.
The advantage of organising around the cycle is that cycles overlap cleanly. Three Seeds planted in the same week can each sit in a different beat (one in Cultivate, one in Inspect, one in Gather) without the team losing track of where each one is. The cycle is the unit. The beat is the moment. The Seed is the work.
The cycle is the unit. The Seed is the work.
Cultivation in the age of agentic build.
The industrial metaphors held while the bottleneck was the typing of code. That era is closing. Agentic coding has collapsed the cost of build: an AI builder can implement a Grow Plan in a session where a team would once have shipped a sprint. The cultivation model is the shape that fits what comes after.
When build is cheap, the scarce resources change. They are no longer engineering hours; they are good Seeds and honest Yield. A bad Seed handed to Claude Code becomes a built mistake at speed. A Harvest with no Measures becomes a launch nobody can read. The bottleneck has moved upstream into judgement: which evidence to trust, which Seed to plant, when to Inspect, what counts as a good Yield.
Cultivate OS is built for the post-synthesis labour split. AI handles the synthesis at every beat: it reads the Inputs and proposes Nutrients, it drafts the Grow Plan, it implements the Tasks. The human holds every cultivation moment: promoting a Seedling, accepting a Seed, opening a Grow Plan, calling a Harvest, reading the Yield, turning the Soil. The work AI cannot take.
AI handles the synthesis. The human handles the judgement.
The PM becomes a steward.
The role of the product manager shifts from specifier to steward. The job is no longer to write the spec at the right grain so engineers can build it; the AI builder fills in detail at any grain. The job is to hold the Field: to keep the Soil honest, to pick which Seed gets planted, to read what the Yield is telling you, to decide what gets turned back in. Stewardship, not specification.
The same shift sits underneath the engineering side of the house. The work of writing code is being handed off; the work of keeping the build honest (choosing which builder, governing its output, catching drift, regenerating when source changes) is what remains. Assay is the surface for that work. The brief handed to Claude Code carries its evidence trail; what comes back is inspected against the Seed and Soil it should honour. A Harvest with its evidence trail.
AI-native, not AI-velocity.
Calling Cultivate OS AI-native is precise. The operating model is built for the world where AI is in the loop at every beat. But AI-native does not mean velocity. It does not mean ship-faster. It does not mean automate-everything. Velocity without judgement is how teams ship the wrong thing at the new, faster pace; AI-native without grounding is how a Seed gets planted that no one can defend six weeks later.
The grounding is the cycle itself. Every Seed cites its Nutrients. Every Harvest has expected Yield. Every Gleaning lands as Nutrient. The cycle is what makes AI-native trustworthy; the human is what keeps it true.
A system, not a process.
Cultivate OS is a system in the engineering sense, not a methodology in the consulting sense. There is shared state: the Field. There is an event loop: the eight-beat cycle. There is an evidence trail: every Seed walks back to its Nutrients, every Measure to its Seed. There is an append-only change log: Growth Rings. There are typed objects (Inputs, Nutrients, Seedlings, Seeds, Grow Plans, Growth, Sheaves, Yield, Gleanings) with explicit transitions between them.
Engineering leaders evaluating Cultivate OS should read it as that: a stateful system with a defined object model, an event loop, and a governance layer that sits above whichever build tool a team runs. It does not replace Claude Code, Cursor or Lovable. It is the layer above them: where the brief comes from, where the result is inspected, and where the learning lands.
What this buys you.
A product team running Cultivate OS for two full cycles develops three habits that survive long after the tool:
The team argues from evidence, not adjectives. Because every Seed carries its evidence trail, the question “why this?” has an answer that anyone in the Field can read.
The team sets Measures before Harvest.Because the Grow Plan demands them up front, retrofitting success is no longer the cheapest option. The discipline transfers to launches outside Cultivate OS too: once it is the team's habit, the tool is no longer the only place it lives.
The team treats learning as material.Gleanings are not summaries to be read once and lost. They are returned to the Field as Nutrients, where the next cycle's Seeds grow from them. The product gets wiser cycle by cycle, instead of refreshing every quarter from scratch.
Where this sits next to Agile, Shape Up, Continuous Delivery.
Cultivate OS is not a delivery framework. It is a decision-making framework. It is about how a team chooses what to plant, defends that choice, measures what it grew, and folds the learning back in. It sits above whichever delivery framework a team runs: Agile, Shape Up, Continuous Delivery, Linear-style flow, or none of the above.
The cycle and the delivery process can interlock at the Grow Plan. A Shape Up shop reads a Grow Plan as a pitch; a Scrum shop slices its Tasks into stories; a Continuous Delivery shop streams Tasks straight to trunk. The Field doesn't care which. What it requires is that every piece of Growth can name the Seed it came from, and every Seed can name its Nutrients.
Teams running Cultivate OS continue to run their delivery framework underneath. Cultivate OS only insists on the discipline of the four promises (cite, measure, return, turn) and is silent on the rest.
A small warning.
Cultivate OS is not the right tool for every team. If your team ships uncited features quickly and that is working, this product will feel like friction. If your evidence chain only has to satisfy yourself, the evidence trail is overhead. If you are happy reading Yield in the rear-view mirror, Tally will feel slow.
We are designed for the team that has felt the cost of those gaps and has decided it is no longer worth paying.
Products are grown, not built. The work is the same.