At a Glance
Bolting AI onto a product team rarely works if the team underneath it hasn’t been redesigned to use it well. This checklist walks through that redesign step by step: confirming a human capability framework already exists, building a parallel machine functionality framework laddered by autonomy rather than proficiency, and designing the hybrid operating interface that choreographs handoffs between the two. It closes with the four practical shifts that follow (decision velocity, role boundaries, discovery loops, ownership), a governance layer that names what each agent capability is allowed to do without a person, and a sense-check to run before rollout. Work through it in order, since later steps assume the frameworks from steps 1 to 4 are already in place.
Don’t simply bolt on AI in your product team. Instead, deliberately re-design your product team to include AI as a part of it.
This list guides you through the process to create a human capability and a machine functionality framework, and the interface that determines what human capabilities are required, how far AI can act on its own, and where it must hand back to a person
1. Foundation check
- Confirm a human capability framework already exists (laddered proficiency, not just job titles). If not, you’ll need to build this first. This step cannot be skipped.
- Validate the capability proficiency descriptors describe demonstrable behaviour (“what someone can be seen to do”), not just knowledge.
2. Build the Human Capability Framework
- Start from portfolio strategy and team objectives, not org structure.
- Derive the activities needed to deliver that strategy.
- Define capabilities required by those activities, laddered across proficiency levels.
- Ensure each level is anchored in observable action.
3. Build the Machine Functionality Framework
- Start from the same portfolio strategy. Ask yourself what does AI need to accomplish across the PM/dev lifecycle?
- Define the capabilities you want agents to cover.
- Ladder each by autonomy, not proficiency: how far can it act alone, at what threshold does it hand back, what error tolerance is acceptable.
- Set up evaluation/observability so agent reliability is evidenced, not assumed.
- Schedule this framework for more frequent review than the human one (it drifts every time the underlying model changes).
4. Design the Hybrid Operating Interface
- Translate human capabilities into role profiles (what people own).
- Translate machine capabilities into process + autonomy rules (what agents operate within).
- For each capability, choreograph the handoff explicitly: what the agent drafts/generates, what point it hands back, and to whom (named role, not a committee).
- Stress-test the seams: where could a handoff fire too late, or where might a human assume the agent hasn’t acted when it has?
- Decide, deliberately, where accountability sits and resist letting it “leak” to “the system” under cost pressure. Remember making products is still a human endeavour.
5. Operationalise the four practical shifts
- Decision velocity:
Separate drafting/option-generation speed from decision-stage pace; name the capability so speed doesn’t create false urgency. - Role boundaries:
Write down and socialise, per role: what it owns outright, what it directs an agent within, where the named handback sits. - Discovery loops:
Build a cadence with an explicit seam: agent-assisted research feeding into a human sense-making session that keeps its full calendar time. - Ownership:
Consolidate each decision to one named human, not a group “across” it.
6. Governance layer
- For every agent capability, document: what it’s allowed to do without us, and how we’d know if it exceeded that.
- Treat this as a living, ongoing discipline (not a one-off sign-off).
7. Sense-check before rollout
- Have you named, precisely, why “generating options” is different from “choosing between them” in your own team’s work? If you can’t articulate this, the boundary isn’t ready to encode.
- Pressure-test with a real scenario: walk a past decision through the interface and see where it would have handed off.
Note, this isn’t a one-off exercise.
The human framework will hold steady for a while because growth on happens gradually, at a pace that we can plan around. The machine framework however won’t. The moment the underlying AI model changes; a version upgrade, a provider swap, a new release, the agent’s actual capability can shift overnight, in either direction. You’ll need to revisit the machine framework every time that happens.
