Define: prioritise AI initiatives and record what holds
Role of the Company Brain: Record what holds and why. With priorities, rationale and owners.
For CEOs and leadership teams who want to prioritise AI initiatives and record decisions so that teams and AI agents can find them. The deep dive is for product and tech leaders.

Define is the second phase: the leadership team sets which AI initiatives take priority, by value, effort and risk. The Company Brain records every decision with its rationale, date and owners, so people and AI agents can find it. The decision then moves on into Build.
Define is the second phase. It sets which AI initiatives take priority and records what holds and why.
Input is the checked version from Discover. Prioritisation runs on value, effort and risk; the Company Brain records every decision with rationale, date and owners. Output is a decision that people and AI agents can find, and it moves on into Build.
The deep dive below shows the method behind it for product and tech teams: spec-driven development, the precise brief that people and agents implement without follow-up questions.
Decisions are made in meetings and stay in the minutes.
Prioritise AI initiatives by value, effort and risk, and record what holds, why and who is accountable.
A decision with rationale and owner that people and AI agents can find.
At the centre: the Company Brain
Every phase draws on the Company Brain and adds new knowledge. The guide explains what it is, who owns it and how quality holds.
Leadership questions in this phase
Answered in the Company Brain guide.
- Where are the decisions made that belong in the Company Brain?
- Who owns the Company Brain?
- Buy or build?
Deep dive for product and tech teams
Vibe coding vs spec-driven development
Vibe coding – software via natural language and iterative prompt trial and error – has its place: prototypes, demos, throwaway tools. In scaling production systems the approach breaks down in two places. Intent drift: after dozens of prompts the result no longer matches the original intent, and nobody can reconstruct where it was lost. Context decay: the chat history serving as the only “documentation” is worthless in the next session.
Spec-driven development counters this with a contract: a versioned specification agreed before an agent is commissioned, connecting business intent with architecture, implementation and tests across the whole lifecycle. What that division of labour looks like in practice – discovery human, execution against the spec – is documented in the deep dive “Discovery stays human, execution becomes the spec”, with evidence from METR, GitClear and DORA.
The comparison below summarises the differences – and makes clear why the choice is not a matter of style but of the kind of system you are building.
| Criterion | Vibe coding | Spec-driven development |
|---|---|---|
| Best fit | Prototypes, demos, throwaway tools | Scalable production systems |
| Source of truth | Chat history and tribal knowledge | Versioned spec in the repository |
| Consistency | Intent drift after a few iterations | The spec keeps intent stable across sessions |
| Review focus | Generated code, line by line | Business intent in the specification |
| Changes | New prompt, new guessing | Updated spec, reproducible build |
| Traceability | None – decisions vanish into the history | Audit trail from requirement to code |
The three maturity levels of spec-driven development
SDD is not all-or-nothing. At the first maturity level, a considered specification is written before each task and used for exactly that task. At the second level the spec persists after completion – as an anchor for maintenance, onboarding and the next iteration. At the third level the specification is the only source file humans still edit: the human changes the spec, the machine manages the source code.
For most teams in the DACH mid-market, level two is the realistic target: long-lived, reviewable specs versioned alongside the code. Level three assumes a discipline and tooling maturity that few organisations reach in 2026 – it works as a direction, not as a starting point.
From wish list to qualified roadmap
Traditionally, features get prioritised by gut feeling or political pressure, without systematically assessing effort and risk. The result is a wish list, not a strategy. An impact and feasibility matrix replaces that with a simple discipline: every feature is scored by measurable business value, expected implementation effort and technical as well as regulatory risk – before resources are released.
AI initiatives add a peculiarity: effort and outcome correlate less predictably than with deterministic features. Scoring models like RICE help, but must be adapted to this uncertainty – for instance with confidence discounts for experimental initiatives. How deterministic commitments and probabilistic bets come together in one plan is covered in “The AI roadmap: features and GenAI initiatives in one plan”.
The PRD as a living artefact in the repository
A PRD ageing in a slide deck is invisible to AI agents. That is why product requirements documents move into the repository: versioned alongside the code, accessible to AI editors such as Cursor or Claude Code in every session. Persistent context files like CLAUDE.md replace the manual briefing – they define product terminology, user journeys and architectural guardrails once, instead of repeating them in every prompt.
The strongest PRD is code-anchored: it references actual components of the codebase instead of abstract descriptions. The prerequisite is a shared language for epics, stories, cycles and acceptance criteria – the “Product management glossary: Jira & Linear terms explained” pins it down, for humans and for the answer engines that will one day quote your specifications.
The BMAD method: structure from idea to production
The BMAD method structures the path from idea to production into clearly separated steps – from analysis through requirements and architecture to delivery. Each step produces a versioned artefact and hands over to the next: brainstorming becomes a PRD, the PRD becomes an architecture, the architecture becomes executable stories. With Git versioning this creates an audit trail showing who decided what, when and why.
For regulated environments this trail is precisely the point: code provenance becomes demonstrable instead of vanishing into chat histories. BMAD does not replace coding tools – it orchestrates them. The spec remains the contract every handover is measured against.
Spec review instead of code review
When agents write the code, review moves forward. Instead of hunting for bugs in generated code, the team reviews the business intent in the specification: are the acceptance criteria complete? Are the edge cases named? Does a requirement contradict an existing business rule? A defect found in the spec costs minutes – the same defect in shipped code costs a rollback.
Product evolution follows the same logic: changes happen by updating the specification, not through new ad-hoc prompts. That makes the system reproducible and iterable – and prevents architectural decisions from getting lost in e-mail threads, or agents' unspoken assumptions from producing faulty code.
Where define ends and build begins
The define phase delivers the blueprint: long-lived, reviewable objects such as specifications, architecture plans and the qualified roadmap. What it does not deliver is software. The build phase picks up the blueprint and transforms it into reviewed, shipped code via ticket structures and agentic engineering.
Drawing this line deliberately is the chapter's most important move: the spec is agreed before the agent builds – the gate. It costs no speed, it prevents rework. The METR, GitClear and DORA data from the division-of-labour deep dive show that unstructured AI use measurably slows teams down and lowers code quality.
Deep dives for this phase
Each article answers a concrete question from the practice of product and tech teams.
Spec-driven development for agentic software engineering: the spec as the contract
The 2026 UPM paper: the productivity paradox as a governance gap, eight harness mechanisms, five interaction patterns – linked to the PM Grader and the Playbook.
Read post Focus: spec-driven development product managementDiscovery stays human, execution becomes the spec
The division of labour between PM and agent in brownfield – with evidence from METR, GitClear, DORA and Anthropic.
Read post Focus: AI product roadmap softwareThe AI roadmap: features and GenAI initiatives in one plan
Two-lane roadmap, RICE scoring and code reality as the corrective – commitments and bets in one plan.
Read post Focus: AI skill filesSkill files: the next AI skill after prompting
One-page operating manuals an AI follows without follow-up questions – from the first file to a team library with owners.
Read post Focus: AI tools for product managersAI tools for product managers: the stack that carries context
The smallest stack that covers the whole cycle with real context – from the conversation to the ticket.
Read post Focus: structured AI workflowsStructured AI workflows: structure beats prompts
AI amplifies structure or chaos – curated context, an agreed division of labour and checkpoints decide the payoff.
Read post Focus: enterprise AI playbookBuild your own company brain: the enterprise AI playbook from Stripe's engineering team
One AI layer instead of a hundred copilots, projects as the unit of governance, skills as company IP and the infrastructure agents amplify – and the same shape for the product lifecycle.
Read post Focus: PM work in the AI eraHow PM work is changing in the AI era: AI moves the bottlenecks
Casey Winters' interviews with product managers plus telemetry from Faros AI and DORA: the bottleneck moves from coding to design, integration, alignment and judgement – prioritisation becomes a core skill again.
Read post Focus: product management glossary Jira LinearA shared language: the PM glossary for Jira & Linear
Work units, planning, metrics – the vocabulary your specs and tickets are steered with.
Read postMatching Activities from the Playbook
From the article straight into practice: these Activities put the concepts to work with Teklens.
Frequently asked questions
What is spec-driven development?
Spec-driven development is a development methodology in which a structured, versioned specification serves as the single source of truth. Requirements, constraints, acceptance criteria and edge cases are agreed before code exists; AI agents then build against this spec instead of vague prompts. Product changes happen by updating the specification.
How does spec-driven development differ from vibe coding?
Vibe coding works with natural language and iterative trial and error – fine for prototypes, but in production systems it fails on intent drift and context decay. SDD agrees the intent in writing up front and keeps it stable across sessions, releases and team changes. The difference is not style but traceability.
Does the spec replace classic requirements management?
It is requirements management – in machine-readable form. What used to be scattered across requirement tomes and ticket fields becomes a versioned source that humans and agents read alike. What is new is not the discipline but its addressee: the spec is executed by software, not just interpreted by people.
What belongs in a spec for AI agents?
The goal and its why, the requirements, explicit constraints, measurable acceptance criteria and the known edge cases – code-anchored wherever possible. Plus the non-negotiable guardrails: architecture principles, security rules, regulatory obligations. Short enough to be maintained; precise enough that an agent doesn't guess.
What is the BMAD method?
A framework that structures the path from idea to production into separate steps with versioned artefacts – analysis, requirements, architecture, delivery. Every handover is documented; with Git this creates an audit trail. That makes BMAD particularly relevant for regulated environments where code provenance must be demonstrable.
Next phase in the cycle
From Define to Build: the decision goes in, work that follows the new version comes out. The Company Brain shows where tickets, code and documents still follow old instructions.
Phase 03 · Build – Build


No new piece without you.
New articles, new interactive tools, new evidence – in your inbox first. And when you reply, we reply: you write directly with the authors, not with a no-reply.
No spam, no sharing, unsubscribe any time.
Bring one important decision.
Discovery Call: 30 minutes with a founder. Bring an important decision or a concrete context problem.
With a founder. No obligation.