The AI-Native Product Builder.
Product and engineering roles are converging. AI agents now generate production-grade code, specifications, and test suites. The bottleneck has shifted from building to deciding what to build, and validating that it's right.
This is how we see the next generation of product builders: people who own outcomes end-to-end, directing AI to build while they focus on the problems worth solving.
The core loop.
Seven steps, repeated continuously. AI generates. The team validates. Context carries forward.
- Understand the problem: talk to users, review the signal, define what "worked" means
- Direct AI to generate specifications, user journeys, and test cases
- Review and refine AI output for accuracy and completeness
- Validate with stakeholders: users, product, design, engineering
- Direct AI to implement based on validated specs
- Review and ship through CI/CD
- Close the loop: prove the outcome worked, proportionate to the bet
“I focus on value-driving outcomes. AI builds production-grade software.”
Operating principles.
Seven principles underneath the loop: how the role owns problems, runs the work, and feeds the system that makes the next build easier.
Own the problem
Understand the customer problem before specifying. When the problem isn't understood, everything downstream inherits the gap.
Specify and build with AI
Direct AI, then review every output against intent. The quality of the thinking determines what ships.
Prove it worked
Close the loop proportionate to the bet. A small fix needs a quick check; a programme needs a defined metric.
Own the outcome
One directly responsible individual per initiative, owning timeline, scope, quality, and the call to ship. Autonomy compounds through visible reasoning.
Prioritise ruthlessly
Context on the table first. Ask whether the work should exist at all, then order by impact, urgency, and effort.
Operate and improve
Protect initiative time from the day-to-day. Root-cause recurring issues instead of re-fixing them each time.
Invest in the system
Encode constraints so the AI holds them. Every failure traced back to its cause makes the system stronger.
What this role does.
10%Research & Discovery
Talk directly to users to understand their problems. Analyse usage data and support tickets. Capture user stories, pain points, and desired outcomes. Define success metrics for features you own.
10%AI-Assisted Prioritisation
Classify incoming work with the full context on the table, then order by impact, urgency, and effort. The Distractable test: with all context shared, if nobody can articulate the commercial outcome in one sentence, decline it.
30%AI-Assisted Specification
Direct AI to generate specifications: use cases, user journeys, entity relationship diagrams, sequence diagrams, business process diagrams, and state diagrams.
15%Stakeholder Validation
Walk through user journeys with users and stakeholders. Present designs to product managers, designers, and engineering leads. Gather feedback and direct AI to incorporate changes. Obtain sign-off before implementation.
15%AI-Assisted Test Definition
Ensure tests at all levels of the testing pyramid: unit tests, component tests, integration tests, and end-to-end tests. Tests are defined before implementation.
10%Implementation & AI Orchestration
Direct AI coding agents. Provide context: validated specs, approved test cases, codebase patterns. Ensure AI writes tests first, then implementation. Review AI-generated code for correctness, security, and maintainability.
5%CI/CD & Delivery
Ensure all code passes automated quality gates before merge. Monitor build health, test coverage, and production health.
5%Prove It Worked
Validate the outcome in production: did the shipped work solve the problem? Check proportionate to the bet, and feed the learning back into the next cycle.
Core competencies.
01 Product Discipline
"Just because you can build it, doesn't mean you should."
AI makes it easy to build more, faster. Every feature carries an ongoing cost. It needs maintenance, creates complexity, and adds cognitive load for users. The job isn't to build as much as possible; it's to build only what creates genuine value.
| Aspect | Old World | AI-Assisted World |
|---|---|---|
| Building Speed | Slow → natural restraint | Fast → temptation to build more |
| Idea Filtering | High cost filters out bad ideas | Low cost means bad ideas get built |
| Output per Builder | Limited output per builder | Unlimited output per builder |
| Prioritisation | Scarcity forces prioritisation | Abundance requires discipline |
Questions to Ask Before Building
| Question | Signal |
|---|---|
| What problem does this solve? | Don't build it |
| How many users have this problem? | Consider if it's worth the cost |
| How painful is the problem? | Low pain = low value |
| What happens if we don't build it? | If nothing bad, don't build it |
| Can we solve it without new features? | Documentation, UX improvement |
| Does this align with our product vision? | Feature creep is real |
02 Prioritisation & Commercial Thinking
Every feature request must pass through the prioritisation framework. AI helps classify; you make the call.
Detractable: Non-Negotiable
Features that generate zero satisfaction when working, but cause churn when broken. Revenue protection.
Comparable: Competitive Parity
Features where customers compare you to competitors. Invest until parity, then stop. Revenue maintenance.
Delightable: Structural Advantage
Features users don't expect. Creates new categories competitors don't have. Revenue acceleration.
Unblocking: Infrastructure
Tech debt that blocks shipping speed by >25%. Velocity multiplier, not feature velocity.
Distractable: Decline It
Features that consume effort without moving metrics. "Does this move churn, deal velocity, or differentiation?" If the answer is "it's nice to have," decline it.
03 AI-Assisted Specification & Validation
Process: Capture → Direct AI → Review → Validate
AI Specification Review Checklist
- Accuracy: Does this match what the user said?
- Completeness: Are all scenarios covered?
- Consistency: Do artefacts align with each other?
- Feasibility: Can we actually build this?
- Edge Cases: What happens when X fails?
- Clarity: Would another builder understand?
04 User Journey Validation
Map the journey. Walk it with users. Challenge every assumption.
Journey Validation Questions
- Steps: Is this the actual sequence users follow?
- Emotions: How do users feel at each stage?
- Pain Points: What frustrates users?
- Alt Paths: What happens when things go wrong?
- Touchpoints: What systems does the user interact with?
- Data: What information flows at each step?
05 Stakeholder Engagement
| Stakeholder | Concern | Validation |
|---|---|---|
| Users | Does this solve my problem? | Walk through journey |
| Product Manager | Does this meet business goals? | Review requirements |
| Designer | Is the flow intuitive? | Review journeys, UI states |
| Tech Lead | Is this technically feasible? | Review ERDs, API design |
| QA | Is this testable? | Review test scenarios |
06 Test-First Mindset
Tests are defined before implementation. AI agents must write tests that match your specifications.
Testing Pyramid
| Level | Volume | Speed | Confidence |
|---|---|---|---|
| E2E Tests | Few | Slow | High |
| Integration Tests | Some | Medium | Medium-High |
| Component Tests | More | Fast | Medium |
| Unit Tests | Many | Very Fast | Targeted |
Test Scenario Format (Given-When-Then)
Feature: Order Placement
Scenario: Successfully place an order
Given a customer with items in their cart
And the customer has a valid payment method
When the customer submits the order
Then the order is created with status "pending"
And the customer receives a confirmation email
07 CI/CD Understanding
Continuous Integration
Build → Lint → Test → Security → Coverage
Continuous Deployment
Staging → Smoke Tests → Production → Monitor
How this works.
AI generates. The team validates. Context carries forward. And the loop only closes once the outcome is proven.
“If the logic can't be explained to a peer, it hasn't been reviewed.”
Backlog
Intake from OKRs, internal tickets, customer requests. Prioritise based on value and "Should we build this?" check.
Pre-Design (AI)
AI structures request, identifies assumptions, gathers context, generates clarifying questions.
In Design (AI)
AI generates use cases, ERDs, sequence diagrams, user journeys, test scenarios, and acceptance criteria.
In Review (Human)
Builder reviews specs, validates with stakeholders, approves or rejects with feedback.
To Do
Design approved, tests defined, acceptance criteria clear. Ready for implementation. Receives failure returns with context.
In Progress (AI)
AI writes tests first, then implementation. Follows codebase patterns. Commits atomically.
CI (Auto)
Build, lint, unit tests, integration tests, security scan, coverage check. Failures return to To Do with 5 Whys.
Awaiting Approval (Human)
Builder reviews PR, verifies implementation matches design, checks test coverage. Approves or requests changes.
Deployment (Auto)
Deploy to staging, smoke tests, deploy to production, health checks. Failures rollback and return to To Do.
Shipped
PR merged, deployment successful, production healthy. Docs updated, stakeholders notified. The code is live, but the outcome isn't proven yet.
Prove it worked
Close the loop proportionate to the bet: check the outcome against what "worked" was defined as before building. Feed the learning back into the backlog. If it didn't work, own the call to iterate, pivot, or remove.
Closing the loop, proportionate to the bet
Shipping isn't done when the code reaches production. A feature that ships but doesn't solve the problem still needs maintaining, and that cost compounds. Match the depth of the check to the size of the bet, then feed what you learn back into the backlog.
| Size of bet | Measurement |
|---|---|
| Small fix / BAU | A quick check: did the support tickets stop? Did the error rate drop? The signal is already visible. |
| Sprint-sized initiative | Define what "worked" looks like before building. Check it after shipping: support volume, usage, customer feedback. Lightweight, not instrumented. |
| Programme-level initiative | Define a success metric before building. Instrument it. Review at 30 days. This is the one that earns a dashboard. |
On failure: the 5 Whys
When CI or Deployment fails, perform root cause analysis before retrying:
- Why did the check fail?
- Why was that the case?
- Why was it not caught earlier?
- Why is that the root cause?
- What must change?
Workflow constraints
- AI generates, Human validates: AI executes within constraints. Humans approve at gates.
- Context carries forward: Failures include full context for informed retry.
- 5 Whys on failure: AI interrogates itself before retrying.
- Notifications at gates: Humans know when action is required.
- Product discipline throughout: "Should we build this?" at every stage.
Training pathway.
A 12-week programme that takes someone from fundamentals to independently shipping features.
Weeks 1–3: Foundations
Product Discipline
The product mindset. User cognitive load. When NOT to build.
Prioritisation Framework
The 5 categories and commercial outcomes. The "one-sentence commercial outcome" test. Recognising Distractable. Decision tree for situational priorities.
Understanding Specifications
Reading use cases. Understanding ERDs. Sequence diagrams. User journeys.
Git Fundamentals
Branching and merging. Pull requests and code review. Commit hygiene. Resolving conflicts.
Testing Fundamentals
Testing pyramid. Given-When-Then scenarios. Coverage concepts.
CI/CD Basics
Pipeline concepts. Quality gates. Deployment strategies.
Weeks 4–6: AI-Assisted Specification
AI-Assisted Prioritisation
Prompting AI to classify backlog items. Reviewing AI's category recommendations. Using AI to detect Distractable patterns. Generating velocity impact estimates.
Generating Specs with AI
Prompting AI for use cases, ERDs, user journeys, and test scenarios.
Reviewing AI Output
Accuracy checking. Completeness validation. Consistency across artefacts. Identifying gaps and errors.
Validation Skills
Walking through journeys with users. Presenting specs to stakeholders. Gathering and incorporating feedback. Getting sign-off.
Weeks 7–9: AI-Assisted Implementation
Generating Code with AI
AI coding agent basics. Providing validated specs as context. Test-first implementation. Code review and iteration.
End-to-End Features
From user need to validated spec. From spec to approved tests. From tests to implementation. From implementation to deploy.
Weeks 10–12: Mentored Delivery
Own a Small Feature
Capture requirements → Generate specs → Validate → Generate tests → Implement → Ship
Graduation Criteria
- Correctly categorise requests using prioritisation framework
- Specs validated by stakeholders without major rework
- Tests cover all acceptance criteria
- AI-generated code has <10% revision rate
- Feature ships without incidents
- Demonstrated ability to decline Distractable requests
What success looks like
After 3 Months
- Own features independently
- AI specs require minimal revision
- Test coverage meets standards (>80%)
After 6 Months
- Own a feature area
- Conduct validation sessions independently
- Mentor new AI-Native Product Builders
After 1 Year
- Lead medium-sized projects across multiple repos
- Known for thoughtful pushback: "Have we considered not building this?"
- Demonstrate measurable user impact (not just features shipped)
- Advocated for removing or simplifying existing features
Who thrives in this role.
This role is for you if…
- You enjoy understanding problems before solutions
- You're comfortable saying "we shouldn't build this"
- You believe simplicity is a feature
- You like reviewing work for accuracy
- You're comfortable with stakeholders
- You see AI as a tool needing human oversight
- You want to own outcomes, not just tasks
This role is NOT for you if…
- You measure worth by how much you ship
- You feel unproductive when not building
- You find it hard to say no to requests
- You want to work without stakeholder interaction
- You trust AI output without critical review
- You prefer to skip testing to ship faster
- You avoid presenting or explaining your work
Foundational Skills
- Understanding of programming fundamentals
- Basic web architecture knowledge
- Ability to read and understand code
- Clear written and verbal communication
AI-Assisted Skills
- Direct AI to generate specs
- Critically review AI output
- Identify gaps and errors
- Iterate with AI to refine
Attitude
- Healthy scepticism of AI output
- Curiosity about user problems
- Takes ownership of outcomes
- Restraint: comfortable saying no
- Values simplicity over comprehensiveness
Want to transform your product team?
We help organisations build AI-native product teams, from defining the role to training and embedding the workflow. Whether you need advisory, an engagement, or fractional leadership to make it happen.
Prefer email? hello@llma.ai
Explore how we work: Engagement & Advisory · Startups & Investors