## Background
Published on YouTube by the Ai4 channel on August 18, 2026, this presentation features Josh Guice, Principal Architect at Liatrio. The session demonstrates an end-to-end AI-native product workflow showing how AI agents can extend productivity beyond software engineering into the entire organization, transforming raw stakeholder conversations into developer-ready user stories.
## TL;DR
Josh Guice outlines the agentic product development lifecycle using a hypothetical scenario involving the Emerald Grove Pet Clinic. The process begins with an AI-recorded stakeholder discovery meeting, followed by context mining across internal systems like SharePoint and source code repositories to create an indexed Context Brief. Using rapid prototyping and feedback loops in Jira and Slack, the team refines user stories with BDD Gherkin acceptance criteria before executing implementation via Liatrio's open-source Spectrum framework CLI, complete with automated proof artifacts. The session concludes with a Q&A discussing human-in-the-loop validation, evolving product owner roles, and the future of generative UI.
## Atmosphere & style
The presentation is informative, practical, and highly structured, blending technical expertise with relatable humor—such as a lighthearted slide featuring an AI-generated launch dance. Guice maintains a clear, instructional, and engaging narrative style that grounds high-level enterprise AI concepts into a practical, step-by-step walkthrough. The interactive Q&A session creates a thoughtful and collaborative environment where complex questions about engineering judgment, skill gaps, and agent autonomy are candidly explored.
## Key takeaways
- [00:04](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=4s) The agentic product development lifecycle focuses on accelerating early product phases—from initial exploration and validation to early development—to streamline organizational throughput from 'aha' to 'cha-ching'.
- [02:27](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=147s) Cross-functional stakeholder discovery meetings capture diverse priorities—such as client demand, PCI compliance, UX accessibility, and front-desk friction—which are recorded to maintain rich context.
- [04:29](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=269s) AI agents extract business constraints from transcripts and perform progressive context discovery by mining internal SharePoint docs, accessibility guidelines, and source control repositories into a consolidated Context Brief.
- [07:20](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=440s) Rapid prototyping using functional AI builds enables asynchronous feedback loops that uncover runtime edge cases—such as missing loading indicators or missing itemized receipt details—much faster than static wireframes.
- [10:41](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=641s) Codifying acceptance criteria into BDD Gherkin syntax and attaching the indexed Context Brief to Jira stories provides autonomous AI agents with deterministic feedback loops needed for self-correction.
- [12:43](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=763s) Developer execution via an agentic CLI (using Liatrio's Spectrum framework) follows a structured workflow: specification generation, task list generation, test-driven execution (Red-Green-Refactor), and automated validation.
- [12:43](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=763s) To verify feature compliance before human review, agentic development CLIs generate proof artifacts, including execution logs and MP4 video recordings of automated UI interaction.
- [16:04](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=964s) Engineering judgment and technical architecture skills remain necessary because AI agents rely on experienced developers to answer complex technical questions regarding security, scalability, and system backoff strategies.
- [16:04](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=964s) The evolution of the Product Owner role shifts focus away from manual administrative task creation toward high-level strategy, customer discovery, and roadmap management.
- [19:02](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=1142s) Human-in-the-loop validation remains critical for auditing context briefs and verifying unindexed organizational knowledge before launching autonomous agent workflows.
- [19:02](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=1142s) Emerging standards like Model Context Protocol (MCP) and dynamic generative UI interfaces are paving the way for AI-native product workflows where software interfaces adapt on the fly.
## Detailed walkthrough
### [00:04](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=4s) Introduction and the Agentic Product Development Lifecycle
Josh Guice, Principal Architect at Liatrio, opens the session by thanking attendees for making the trek up to the fifth floor for the last talk of the final conference day. Working in Liatrio's internal and client enablement innovation space through forward-deployed engineering and one-on-one pairing, Guice focuses on showcasing the "agentic product development lifecycle." He connects his presentation to prior discussions about streamlining the early phases of the product value stream before features ever reach active software engineering.
The end-to-end organizational value stream spans from initial idea generation to deployed customer value—what Liatrio’s CEO calls the journey "from *aha* to *cha-ching*." By zooming in on the segment between exploration, validation, and early development, teams can eliminate ambiguity and streamline throughput.
```mermaid
flowchart LR
accTitle: Organizational value stream
A(["Aha!"]) --> B["Market listening and research"]
B --> C["Validation and definition"]
C --> D["Development"]
D --> E(["Cha-ching!"])
classDef milestone fill:#7c3aed,stroke:#5b21b6,color:#ffffff,stroke-width:2px
classDef stage fill:#f5f3ff,stroke:#8b5cf6,color:#312e81
class A,E milestone
class B,C,D stage
```
- **Speaker:** Josh Guice, Principal Architect at Liatrio.
- **Core Focus:** Efficiency gains early in the value stream (exploration to validation and hands-on development).
---
[02:27](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=147s) The Emerald Grove Pet Clinic Use Case and Stakeholder Discovery Meeting
To make these concepts concrete, Guice presents a scenario involving the "Emerald Grove Pet Clinic," an aging veterinary clinic attempting to implement online payment processing for its clients. The feature development process begins with a cross-functional alignment meeting recorded by an AI assistant to maintain rich conversational context. Each team member brings distinct concerns and priorities to the table:
Dr. Carter, who runs the clinic, notes that pet owners continuously request online payment options. Dan, the developer, raises immediate concerns about PCI compliance and the risks associated with handling raw credit card data. Lisa, the UX designer, emphasizes user accessibility so clients of all demographics can navigate the flow seamlessly. Tom, the office manager, pushes for quick delivery to reduce chaos at the front desk, where waiting lines and restless pets create daily friction. Sarah, the product owner, concludes the meeting by committing to generate a clickable prototype by the end of the day using her AI agent.
- **Stakeholders:**
- Dr. Carter (Clinic Lead) — Driven by client demand for online options.
- Dan (Developer) — Focused on card data compliance and risk.
- Lisa (UX Designer) — Prioritizes clear, accessible user flows.
- Tom (Office Manager) — Needs fast deployment to ease front-desk congestion.
- Sarah (Product Owner) — Coordinates discovery, agent orchestration, and rapid prototyping.
---
[04:29](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=269s) Transcript Extraction and Context Mining Across Internal Knowledge Systems
Back at her desk, Sarah instructs her AI agent to process the meeting transcript, extract primary business outcomes, and link requirements directly back to individual speaker statements. The agent identifies core constraints: focus strictly on visit payments rather than specialized pet food purchases, keep the checkout clean, and mitigate compliance risks by outsourcing processing to a third-party payment provider.
```mermaid
flowchart TD
accTitle: Context mining engine
A["Meeting transcript"] --> D["Consolidated context brief"]
B["SharePoint documents"] --> D
C["Source repositories"] --> D
classDef source fill:#ecfeff,stroke:#0891b2,color:#164e63
classDef output fill:#7c3aed,stroke:#5b21b6,color:#ffffff,stroke-width:2px
class A,B,C source
class D output
```
To enrich this baseline, Sarah tasks her agent to mine internal systems across the organization:
- **SharePoint Documents:** Uncovers a documentation artifact detailing a 2024 payment feature that had been previously shelved.
- **Web Accessibility Policy:** Pulls existing organizational UI accessibility guidelines to ensure compliance.
- **Source Control Repositories:** Locates the codebase for the main clinic web app, the separate billing service backend, and the old pull request (PR) from the prior feature spike.
Sarah synthesizes these discoveries into a unified "Context Brief"—an indexed directory containing links back to original sources. This brief establishes complete data provenance and allows downstream AI sessions to perform progressive context discovery without losing critical historical constraints.
---
[07:20](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=440s) Rapid Prototyping, Real-Time Feedback Loops, and Iterative Edge-Case Discovery
Sarah logs a tracking spike in Jira and prompts her AI assistant to build a v1 payment prototype using the gathered context brief. Sharing the functional prototype in Slack triggers an immediate, asynchronous validation loop that uncovers runtime edge cases static wireframes often miss.
```mermaid
flowchart LR
accTitle: Rapid iteration and feedback loop
A["v1 · Lisa tests · 57 duplicate charges"]
B["v2 · Tom tests · Needs itemized receipts"]
C["v3 · Dr. Carter approves · Move to stories"]
A -->|"Fix submission state"| B
B -->|"Add itemized receipts"| C
classDef issue fill:#fff1f2,stroke:#f43f5e,color:#881337
classDef revision fill:#fff7ed,stroke:#f97316,color:#7c2d12
classDef success fill:#ecfdf5,stroke:#10b981,color:#064e3b,stroke-width:2px
class A issue
class B revision
class C success
```
During testing, UX designer Lisa repeatedly clicks the payment submission button when no visual confirmation appears, unwittingly executing 57 duplicate test card charges. Recognizing the flaw, Sarah generates a v2 prototype with disabled submit buttons and visual loading indicators. Office manager Tom tests v2 and notes that clients require detailed, itemized receipts for pet insurance claims. Sarah iterates with the AI to launch v3, introducing automated email receipts containing claim-ready breakdowns. Dr. Carter validates v3, giving the go-ahead to transition the feature toward production scoping.
---
[10:41](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=641s) Scoping User Stories with BDD Gherkin Criteria and Context Briefs
With the prototype validated, Sarah asks her AI assistant to translate the accumulated context, prototype logic, and stakeholder feedback into concrete Jira epics and developer-ready user stories. The initial spike is closed, establishing a baseline for the discovery phase's duration.
To make the user stories clear for both human developers and downstream AI tools, acceptance criteria are codified using behavior-driven development (BDD) via Gherkin syntax (`Given... When... Then...`). The complete Context Brief is attached directly to the Jira tickets. Providing codified criteria and linked context gives autonomous coding agents the deterministic feedback loops necessary to self-correct during generation.
- **BDD/Gherkin Integration:** Translates plain-language user needs into executable acceptance tests.
- **Context Attachment:** Passes indexed repository links and historical decisions directly into engineering tickets.
---
[12:43](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=763s) Developer Execution via Agentic CLI and Spectrum Development Workflows
Developer Dan picks up the ticket for the checkout page and launches an agentic command-line interface (CLI) loaded with custom development skills, including Liatrio's open-source "Spectrum" development framework (available in the Liatrio Labs GitHub repository). The Spectrum workflow guides agentic software generation through structured phases:
1. **Step 1: Specification Generation:** The agent ingests the Jira story, attached Context Brief, BDD scenarios, and developer instructions (such as strictly enforcing test-driven development). If ambiguity remains, the agent prompts the developer with clarifying questions; for instance, agreeing to stub out the payment gateway behind a feature flag for early deployment.
2. **Step 2: Task List Generation:** The specification is broken down into modular tasks, including drafting codified BDD integration tests and TDD unit tests.
3. **Step 3: Execution (Red-Green-Refactor):** The CLI agent writes failing tests first (Red), implements code to pass the tests (Green), and cleans up the code architecture (Refactor).
4. **Step 4: Automated Validation & Proof Artifacts:** The agent executes the built UI and outputs proof artifacts—including test result logs and an MP4 video recording of the agent navigating the checkout flow—to verify feature compliance before human review.
```mermaid
flowchart LR
accTitle: Spectrum development CLI workflow
A["1 · Specification<br/>Clarifying questions"]
B["2 · Task scoping<br/>BDD tasks"]
C["3 · TDD execution<br/>Red · Green · Refactor"]
D["4 · Validation<br/>MP4 and log proof"]
A --> B --> C --> D
classDef plan fill:#eef2ff,stroke:#6366f1,color:#312e81
classDef build fill:#f5f3ff,stroke:#8b5cf6,color:#4c1d95
classDef proof fill:#ecfdf5,stroke:#10b981,color:#064e3b,stroke-width:2px
class A,B plan
class C build
class D proof
```
---
[16:04](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=964s) Q&A: Skill Gaps, Engineering Judgment, and the Evolving Role of the Product Owner
Following a comedic AI-generated video showing the project characters performing an awkward launch dance, Guice opens the floor to audience questions.
An audience member asks about the narrowing gap between Product Managers (PMs) and Developers, questioning what skills PMs currently lack to take features directly from prototype to production, and how junior engineers will adapt. Guice notes that simple technical tooling hurdles often stand in the way—such as PMs working on Windows environments while engineering pipelines are built around macOS. Furthermore, deep architectural judgment remains essential; AI agents frequently ask complex technical questions regarding exponential backoff strategies, security constraints, and system scalability that require experienced developer oversight.
A second question asks whether the Product Owner role remains necessary if AI agents can record meetings and route tasks autonomously. Guice responds that while routine admin work will vanish, the Product Owner's strategic role becomes even more critical. Rather than spending time manually writing tickets, product leaders can focus on real customer discovery, strategic roadmap ownership, and high-level product vision.
- "From *aha* to *cha-ching*."
- "Anything that gives AI a chance to validate the result of its own action, and check that it's done the right thing, is going to get you better results."
- "Codifying knowledge and getting it out of heads and into systems where AI can discover it to get better results."
[19:02](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=1142s) Human Validation, Agent Autonomy, and the Future of AI-Native Products
The discussion opens with a focus on how product managers interact with AI agents during product prototyping. When prototyping with customers—possibly even in real time to gather immediate feedback—the human product owner remains essential in the loop. While parts of the process were trimmed for time, the presenter highlights that when a context brief is generated, the product manager must validate it to ensure nothing is missing that might exist outside connected knowledge bases like SharePoint or Confluence.
An audience member asks whether proper version control could enable an agent to work entirely autonomously, allowing the product owner to review changes retroactively and strip out unnecessary functionality. The presenter agrees, explaining that a product owner can build up the overarching business context and instruct agents to continuously validate their work against those principles.
In an advanced iteration of this workflow, AI agents could autonomously conduct market research and spin up new product versions for product owners or customers to test—provided token costs are managed. The presenter references Anthropic's demo of "William Shakespeare's computer" from the Claude 3.5 Sonnet release, where generative UI created interfaces on the fly as the user clicked. Looking forward, emerging standards like Model Context Protocol (MCP) applications will further drive this shift toward dynamic, AI-native product creation.
- **Human in the Loop:** Product managers validate context briefs against unindexed knowledge stored in platforms like SharePoint or Confluence.
- **Autonomous Agent Workflows:** Version control enables agents to execute tasks independently while product owners audit changes and refine business context.
- **Generative UI & MCP:** Dynamic user interfaces generated on the fly—highlighted by Anthropic's Shakespeare computer demo—and standards like MCP are shaping the future of product development.
## Notable quotes
> [00:04](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=4s) from aha to cha-ching — Josh Guice
> [16:04](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=964s) Anything that gives AI a chance to validate the result of its own action, and check that it's done the right thing, is going to get you better results. — Josh Guice
> [16:04](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=964s) Codifying knowledge and getting it out of heads and into systems where AI can discover it to get better results. — Josh Guice
## Mentioned
Josh Guice, Liatrio, Emerald Grove Pet Clinic, Dr. Carter, Dan, Lisa, Tom, Sarah, Jira, Slack, Spectrum, Liatrio Labs GitHub repository, Anthropic, Claude 3.5 Sonnet, Model Context Protocol (MCP), SharePoint, Confluence
## Video description
Josh Guice - Principal Architect, Liatrio
See firsthand what it takes to extend AI-powered productivity from engineering to the rest of the organization. In this session, we follow a complete workflow end to end: a feature goes from a raw stakeholder conversation to fully scoped, developer-ready stories, with AI agents pulling in context from the team's existing docs and tools along the way. You'll watch every step and every artifact unfold on screen, and judge for yourself what it would take to get AI speed out of engineering and into the rest of the team.
Josh Guice, Principal Architect at Liatrio, argues that applying autonomous AI agents to early product discovery and validation eliminates downstream engineering ambiguity and accelerates the delivery lifecycle. Grounding agents in curated organizational context briefs and executable behavior-driven criteria enables rapid iteration from initial concept to tested code.
Consolidating Organizational Context Into Unified Briefs (4:29)
In Guice's framework, product discovery begins by capturing unstructured alignment discussions and systematically mining internal knowledge systems. In the presented Emerald Grove Pet Clinic scenario, an AI assistant processes a cross-functional alignment transcript to isolate primary business outcomes while mapping requirements directly back to individual stakeholder statements. The agent then queries internal repositories, retrieving a shelved 2024 payment documentation artifact from SharePoint, organizational web accessibility guidelines, and existing billing codebases.
Product owners synthesize these scattered inputs into an indexed 'Context Brief' with provenance links back to source material. This document serves as a persistent foundation for subsequent agentic workflows, enabling progressive context discovery without losing historical constraints. Guice notes that human validation remains necessary during this step to verify that unindexed organizational knowledge stored outside connected tools is not omitted.
Interactive Prototyping Uncovers Runtime Edge Cases (7:20)
Rather than relying on static wireframes, the agentic lifecycle uses the context brief to generate functional prototypes immediately after discovery. Sharing interactive versions across asynchronous communication channels like Slack creates tight feedback loops that surface runtime flaws early. During the clinic demonstration, UX designer Lisa discovered that repeated clicks on an unconfirmed submission button triggered 57 duplicate test card charges.
This immediate feedback allowed product owner Sarah to iterate rapidly, prompting the agent to produce a second version with disabled submission states and visual loading indicators. Subsequent testing by office manager Tom revealed that pet owners needed itemized receipts for insurance claims, prompting a third prototype iteration with automated breakdown receipts. Dr. Carter, the clinic lead, validated this third version before any production engineering began.
Codified BDD Scoping and Structured Agentic Development (10:41)
Once prototype functionality is validated, the accumulated context and feedback are translated into Jira tickets structured with Behavior-Driven Development (BDD) Gherkin syntax (`Given... When... Then...`). Attaching both executable acceptance criteria and the original Context Brief provides autonomous software engineering agents with deterministic guardrails and self-correcting feedback loops.
For implementation, developers execute Liatrio's open-source 'Spectrum' CLI framework, which divides work into structured phases. The agent ingests the ticket, clarifies ambiguities with the engineer (such as stubbing external payment gateways behind feature flags), generates a modular task list, and executes code using a Red-Green-Refactor test-driven methodology. Before human review, the CLI runs the interface and compiles automated proof artifacts, including test logs and an MP4 video of the agent navigating the completed checkout flow.
Technical Judgment and the Strategic Evolution of Roles (16:04)
Addressing concerns regarding the convergence of product management and development, Guice contends that the elimination of administrative overhead—such as manual ticket drafting—elevates rather than diminishes the product owner's role. Product managers shift focus toward strategic roadmap ownership, direct customer discovery, and context curation.
Concurrently, deep engineering judgment remains indispensable. Guice observes that AI agents regularly prompt developers with complex architectural questions regarding exponential backoff strategies, security constraints, and platform scalability. Looking ahead, Guice forecasts that standards like the Model Context Protocol (MCP) and dynamic generative interfaces—exemplified by Anthropic's Claude 3.5 Sonnet demonstration—will expand agent autonomy across market research and interface generation, provided token costs and version-controlled review gates are maintained.
Guice's model demonstrates that agentic efficiency depends on codifying tacit organizational knowledge into accessible repositories and enforcing deterministic feedback loops. However, the workflow relies heavily on human oversight to resolve complex architectural decisions, validate missing institutional context, and manage token economics as autonomous exploration expands.
## Background
该视频由频道 Ai4 于 2026 年 8 月 18 日发布在 YouTube 平台上。内容为 Liatrio 首席架构师 Josh Guice 的主题演讲，旨在展示如何将 AI 赋能的生产力从工程研发拓展至整个组织，通过完整推演一个功能从原始利益相关方沟通、文档上下文挖掘到形成开发就绪工单与交付的端到端全流程。
## TL;DR
Josh Guice 以“翡翠林宠物诊所”新增线上支付功能为例，系统展示了 Agent 原生产品开发生命周期从探索、验证到早期开发构建的闭环。产品负责人利用 AI 代理分析会议转录文本并深挖 SharePoint 文档与旧代码库生成上下文简报，在短时间内迭代出三个交互原型，及时捕获了防抖重复扣款等潜在交互缺陷。随后，团队通过 BDD 与 Gherkin 规范将需求转化为带有精确验收标准的 Jira 工单，开发人员则依托开源的 Spectrum 驱动开发工作流执行自动化测试与红绿重构，并产出浏览器操作录屏作为验证物证。在问答环节，Josh 深入探讨了 PM 角色的重塑，强调人类在校验隐性业务上下文方面的不可替代性，并展望了由 MCP 协议和生成式 UI 驱动的自主智能体未来。
## Atmosphere & style
整场演讲呈现出既风趣亲切又极具极客实战感的基调，Josh Guice 开场以大会尾声“犯困场次”自嘲并伴随模仿 Windows 发布会的幽默舞步，迅速拉近与观众的距离。案例演示节奏紧凑而写实，将 57 次测试扣款的戏剧性失误与多版本原型的敏捷迭代娓娓道来，既有工程视角的严谨推演，又有贴近业务一线的生动细节。随着话题从具体工具链延展至产品经理角色重塑与 Agent 终极形态，整场分享在轻松务实的氛围中自然升华为充满前瞻性与思辨深度的技术探索。
## Key takeaways
- [00:04](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=4s) 价值流（Value Stream）从探索到验证（Aha 到 Ching）的前端环节建立高度清晰度，是提升整个端到端交付效率的核心。
- [04:29](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=269s) 在 AI 原生产品开发流程中，AI Agent 可通过转录会议文本抽取核心诉求，并结合跨系统数据挖掘（如 SharePoint 文档、旧代码仓库与历史 PR）形成全局“上下文简报”（Context Brief）。
- [04:29](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=269s) “上下文简报”不仅汇总业务限制与历史经验，还保留了原始数据溯源链接（Provenance），支持后续 AI 会话实现渐进式上下文发现（Progressive Discovery）。
- [07:20](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=440s) 通过 AI Agent 快速构建可交互原型（如 V1 到 V3 快速迭代），能及早暴露静态设计图无法察觉的时序问题（如按钮防抖缺失导致重复扣款）并快速补齐业务需求。
- [10:41](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=641s) 需求定义阶段采用 BDD 行为驱动开发规范与 Gherkin 语法编写验收标准，将知识代码化（Codifying Knowledge），使 AI 与人类团队具备统一且可机器校验的规范基准。
- [12:43](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=763s) Spectrum 驱动开发（Spectrum-Driven Development）涵盖从规范拆分、任务编排、TDD 红绿重构到最终自动化生成演示视频与测试报告的完整四步闭环。
- [16:26](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=986s) 尽管 AI 极大地赋能了原型设计，但产品经理与完整工程交付之间仍存在环境与工程判断力壁垒（如重试策略、伸缩性与安全合规），因此专业工程师的把关依然不可或缺。
- [16:26](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=986s) Agent 时代并不会淘汰产品经理（PM），而是使其摆脱繁琐的信息录入杂务，真正回归连接客户、洞察业务与规划产品演进的核心定位。
- [19:02](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=1142s) 产品经理在人机协同中承担补充“隐性知识”的关键职责，负责校准并弥补文档库未能记载的业务逻辑缺失。
- [19:28](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=1168s) 未来产品演进趋势将包含智能体自主探索与版本构建、动态生成式 UI（Generative UI）以及基于 MCP（Model Context Protocol）协议实现的无缝多系统上下文互联。
## Detailed walkthrough
### [00:04](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=4s) 探索 Agent 原生产品开发生命周期与价值流
Josh Guice 作为 Liatrio 的首席架构师（Principal Architect），开场调侃自己所在的演讲时段是大会最后一天、位于五楼的“犯困场次”（sleepy time session）。他说明自己目前的工作重心是在公司内部以及为客户推进创新赋能，主导一线前线工程部署（Forward-deployed engineering）与一对一结对协同。本次演讲的核心议题是展示一个“Agent 原生产品开发生命周期”（Agentic Product Development Life Cycle）。任何企业业务都可以抽象为一系列价值流（Value Stream），正如其 CEO 经常概括的那样——从“灵光一闪”（Aha）到“收银入账”（Ching）。
标准的价值流包含倾听市场与客户声音、探索研究、验证设想、定义需求、进入开发及最终交付价值等多个环节。本次分享聚焦于软件进入实际编码开发之前、从“探索到验证”（Exploration to Validation）并延伸至开发早期的关键阶段。Josh 强调，在价值流前段建立高度清晰度，是提升整个端到端交付效率的核心。
```mermaid
flowchart LR
accTitle: 价值流与本次演示关注阶段
subgraph VS["端到端价值流 (Aha to Ching)"]
A["市场与客户探索"] --> B["需求定义与验证"]
B --> C["系统开发构建"]
C --> D["交付与价值实现"]
end
style B fill:#d4edda,stroke:#28a745
style C fill:#d4edda,stroke:#28a745
```
---
### [02:27](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=147s) 翡翠林宠物诊所的线上支付需求与跨角色会议
为了直观呈现工作流，Josh 选取了一个简单而典型的垂直行业案例：一家名为“翡翠林宠物诊所”（Emerald Grove Pet Clinic）的老牌诊所需要新增线上支付功能。团队已经确定要上线该功能，接下来的重点是讨论“如何实现”（How）。会议由产品负责人（Product Owner）Sarah 主持，并全程开启 AI 语音转录记录上下文。
会上各个利益相关方提出了各自维度的关切：
- **Dr. Carter（诊所负责人）**：指出宠物主人一直询问是否能在线结账。
- **Dan（开发工程师）**：担忧合规性（Compliance）与信用卡数据处理带来的风险。
- **Lisa（UX 设计师）**：强调界面必须极其简单易用，兼顾诊所各类客户群体。
- **Tom（前台办公室经理）**：迫切希望功能尽快上线，直言“前台状况非常惨烈”（front line's brutal），排队等待的人群加上猫狗打架让现场极为混乱。
面对诉求，Sarah 承诺当天就会借助 AI Agent 从会议记录中提炼需求，并交付一个可点击的交互原型（clickable prototype）供全员评审。
---
### [04:29](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=269s) 提炼会议上下文与跨系统上下文挖掘
Sarah 回到工位后，指示 AI Agent 解析会议转录文本，抽取核心目标并精确关联到每个发言人。通过结构化梳理，团队明确了初期范围：仅聚焦就诊支付（暂不涉及特殊处方粮购买）、确保结账流程直观，并将底层支付能力外包给第三方专业支付提供商以化解合规顾虑。
随后，Agent 进一步深入诊所现有的内部系统进行上下文“数据挖掘与沉淀”（Mining and Enriching）：
- 在 **SharePoint** 中检索到一份 2024 年被搁置的支付功能设计文档，以及一份全站现行的网页无障碍访问规范（Web Accessibility Policy）。
- 在 **代码仓库与版本控制系统** 中，不仅定位到了诊所门户 Web 应用和独立的计费服务（Billing Service）代码，还找到了当年搁置支付功能时留下的 Spike Pull Request。
```mermaid
flowchart TD
accTitle: 上下文挖掘与上下文简报生成
subgraph Inputs["多源信息输入"]
M["会议转录文本 (Transcript)"]
SP["SharePoint 文档\n(搁置方案/无障碍规范)"]
SC["源码仓库\n(Web门户/计费服务/旧PR)"]
end
subgraph Synthesis["AI 综合与索引"]
CB["上下文简报 (Context Brief)\n- 知识索引\n- 源数据溯源链接"]
Jira["Jira Spike 工单"]
end
M --> CB
SP --> CB
SC --> CB
CB --> Jira
```
Sarah 将挖掘出的所有信息整合成一份“上下文简报”（Context Brief）。该简报如同一个全局索引，不仅汇总了过往经验与业务限制，更保留了回溯至原始系统的溯源链接（Provenance），让后续启动的新 AI 会话能够实现渐进式上下文发现（Progressive Discovery）。
---
### [07:20](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=440s) 敏捷快速原型迭代：从 V1 到 V3 的真实时序验证
Sarah 在 Jira 中创建了 Spike 追踪任务，并调用 AI Agent 的原型构建技能（Prototyping Skill），直接基于上下文简报生成首版支付表单。原型通过 Slack 实时推发给团队评审，在动态交互中暴露了静态设计图无法察觉的时序问题（Time Dimension）：
```mermaid
flowchart TD
accTitle: 原型快速验证与迭代流程
subgraph Iteration["快速反馈循环"]
V1["原型 V1 (基础支付表单)"] -->|Lisa 狂点无响应\n触发57笔测试扣款| V2["原型 V2 (按钮防抖禁用\n+ 成功状态提示)"]
V2 -->|Tom 反馈需要报销凭证| V3["原型 V3 (支持开具收据\n包含宠物保险报销信息)"]
V3 --> Appr["Dr. Carter 与团队验收通过"]
end
```
- **V1 阶段与交互 Bug**：Lisa 点击支付按钮后界面无反馈，连续多次点击导致后台向测试卡发起了 57 笔扣款。Sarah 幽默地庆幸“谢天谢地用的是测试信用卡”。
- **V2 阶段与业务补全**：Sarah 修复了按钮禁用与状态提示后推出 V2。Tom 测试后提出宠物主需要带明细的收据用于向宠物保险公司报销。
- **V3 阶段与最终验收**：加入邮件收据功能后，Tom 实测顺利收到邮件，Dr. Carter 亦对整体流程表示满意，拍板推进生产开发，并建议初期采用小批次发布与特性开关（Feature Flag）控制风险。
---
### [10:41](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=641s) 基于 BDD 与 Gherkin 的需求定义与 Jira 工单生成
原型验证通过后，流程进入定义阶段（Definition Stage）。Sarah 关闭探索 Spike，记录原型耗时，并建立用于特性追踪的 Epic 与基础结账页面 Story。
为了让 AI 代理在开发环节具备自我校验能力，验收标准（Acceptance Criteria）全部采用 Gherkin 领域特定语言进行行为驱动开发（BDD）规范化编写。清晰的自然语言场景描述（如 `Given-When-Then` 结构）与附带在工单中的上下文简报，共同构成了机器与人类均可理解的软件规范。Josh 指出，将知识从人脑中外化并写入系统（Codifying Knowledge），是让 AI 工具发挥最大效能的前提。
---
### [12:43](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=763s) Spectrum 驱动开发：红绿重构与证明产物自动化
开发工程师 Dan 接手 Jira Story 3 后，切入特性分支并启动 Agentic CLI。该环境预载了 Spectrum 开发工作流、Jira 及 SharePoint 等工具技能。Liatrio 将该 Spectrum 驱动开发工作流（Spectrum-Driven Development Workflow）开源在其 GitHub 仓库中，旨在跨不同底层工具提供一致的研究、规划与实现体验。
```mermaid
flowchart TD
accTitle: Spectrum 驱动开发四步法
subgraph SDD["Spectrum-Driven Development 四步工作流"]
S1["Step 1: 生成规范 Spec\n- 澄清模糊疑问\n- 拆分可演示小批次"]
S2["Step 2: 生成任务列表 Task List\n- 编排 TDD 与 BDD 场景代码"]
S3["Step 3: 自动化执行开发\n- TDD 红-绿-重构循环"]
S4["Step 4: 结果验证与证据产物\n- 生成操作视频 (MP4)\n- 输出测试报告"]
end
S1 --> S2 --> S3 --> S4
```
在执行过程中，系统展现出以下关键环节：
- **主动澄清（Clarifying Questions）**：针对尚未接入真实支付提供商的现状，AI 经与 Dan 确认后先采用桩代码（Stub）并在前端埋设特性开关。
- **测试驱动与行为驱动（TDD & BDD）**：严格遵循“编写失败测试 -> 编写实现代码 -> 测试通过并重构”的红绿循环。
- **产物验证与闭环反馈（Step 4 Validation）**：工作流最终生成了一段浏览器自动走通结账流程的演示视频（MP4）和完整的测试报告，让 AI 能够直接“看到自己操作产生的结果”，保证代码实现不偏离轨道。
---
### [16:26](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=986s) 现场问答：PM 技能演进与 Agent 时代的角色重塑
在演示结束后模仿早期 Windows 发布会尴尬舞步的轻松氛围中，Josh 回答了现场观众针对产品经理（PM）与软件工程师边界演变的提问：
- **关于 PM 能否直接从原型跨越到工程交付**：
Josh 坦言当前仍存在现实壁垒。最直观的阻碍甚至包括研发工具链与系统环境的割裂（例如很多 PM 使用 Windows 电脑，而团队工程配置基于 macOS 且缺乏适配支持）。更深层次的差距在于工程判断力（Judgment）——例如面对高并发下的退避重试策略（Exponential Backoff）、系统伸缩性与安全合规考量时，PM 往往缺乏足够的技术背景做出决断。尽管自动化护栏正在持续完善，但现阶段工程师的专业工程把控依旧必不可少。
- **关于 Agent 时代产品经理（Sarah）是否会被取代**：
针对观众提出的“AI 能否直接代管邮箱、参会并生成需求，从而彻底取代 PM”的疑问，Josh 认为虽然职责形态会发生剧变，但核心角色依然不可替代。在更先进的 Agentic 模式下，产品经理将摆脱繁琐的信息转录与工单录入杂务，真正回归“产品所有者”（True Product Owner）的本职——深入对接真实客户、深度洞察业务场景，并全权掌控产品的长期演进路线图。
### [19:02](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=1142s) 人机协同中的产品经理角色与上下文校验
在当前阶段的 AI 原生工作流中，产品经理（PO/PM）依然扮演着不可或缺的关键角色。他们不仅需要与客户进行即时甚至实时的原型沟通以获取反馈，更要在整个链条中把关核心信息。虽然出于演讲时间限制省去了一些细节，但当系统生成上下文简报（Context Brief）时，产品经理的核心任务就是验证这些内容的合理性——凭借其业务敏感度，检查是否存在某些尚未沉淀在 SharePoint 或 Confluence 文档库中的“隐性知识”发生遗漏。行业虽然在全力朝向更高程度的自动化迈进，但眼下仍处于需要人类专家深度介入把关的过渡期。
```mermaid
flowchart TD
accTitle: AI 工作流中的人类反馈与校验
subgraph PO_Loop ["产品经理把关与验证"]
A["上下文简报 / 生成需求"] --> B["核对隐性业务逻辑\n(补充 SharePoint/Confluence 遗漏)"]
B --> C["客户实时原型交互与反馈"]
end
subgraph Agent_Loop ["智能体自主执行与探索"]
D["版本控制跟踪 (Git / History)"] --> E["AI 自主产出迭代版本"]
E --> F["人工审查与回滚 (剪除多余功能)"]
end
C --> D
F --> A
```
- **人类经验的不可替代性**：很多关键业务背景与边缘情况并未被结构化记录在 Wiki 或文档管理系统中，产品经理负责补全这部分上下文缺失。
- **实时原型反馈**：产品人员直接携带由 AI 辅助生成的原型与客户沟通，验证假设并快速收集一手反馈。
### [19:28](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=1168s) 自主智能体、动态生成式 UI 与未来产品演进
随着版本控制机制的完善，现场探讨了一种更激进的协作范式：智能体完全可以自主执行大量工作，而产品负责人只需在事后进行审阅与剪裁，例如直接指出 "Oh, this is a change that you did. Let's wipe that because I don't think that that functionality needs to exist."（这是你做的改动，删掉它吧，我认为这个功能没有存在的必要）。在这种架构下，产品经理的核心职责转变为构建高层级的业务上下文与准则，并要求智能体群按照这套上下文进行自检与验证。
在更高级的终极形态中（假设 Token 成本得以解决或忽略不计），多个智能体甚至可以自主展开市场调研，不断构建并生成出全新的产品版本供产品经理或客户试用。此外，端到端实时生成 UI（Generative UI）也是极具潜力的前沿方向——正如 Anthropic 在发布 Claude 3.5 Sonnet 时展示的“威廉·莎士比亚的电脑”演示，所有界面元素均随用户点击即时生成。结合正在快速普及的 MCP（Model Context Protocol，模型上下文协议）等新兴开放标准，这种极具前瞻性的产品构建方式正在一步步变为现实。
- **业务上下文作为智能体守则**：产品团队负责制定宏观业务上下文与约束标准，由多智能体网络自动对照执行与验证。
- **动态生成式 UI（Generative UI）**：界面无需预先硬编码，依托大模型根据用户交互行为在前端实时渲染生成。
- **开放协议推动生态**：MCP（Model Context Protocol）等新标准的落地，正在大幅降低智能体接入各系统上下文与外部工具的壁垒。
## Notable quotes
> [00:04](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=4s) 犯困场次（sleepy time session） — Josh Guice
> [00:04](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=4s) 从“灵光一闪”（Aha）到“收银入账”（Ching） — Josh Guice
> [02:27](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=147s) 前台状况非常惨烈（front line's brutal） — Tom
> [07:20](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=440s) 谢天谢地用的是测试信用卡 — Sarah
> [10:41](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=641s) 将知识从人脑中外化并写入系统（Codifying Knowledge），是让 AI 工具发挥最大效能的前提。 — Josh Guice
> [12:43](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=763s) 编写失败测试 -> 编写实现代码 -> 测试通过并重构 — Josh Guice
> [12:43](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=763s) 看到自己操作产生的结果 — Josh Guice
> [19:28](https://www.youtube.com/watch?v=8yfiU0oUKzg&t=1168s) Oh, this is a change that you did. Let's wipe that because I don't think that that functionality needs to exist. — Josh Guice
## Mentioned
Josh Guice, Liatrio, Ai4, 翡翠林宠物诊所 (Emerald Grove Pet Clinic), Sarah, Dr. Carter, Dan, Lisa, Tom, SharePoint, Jira, Slack, Confluence, Spectrum-Driven Development, GitHub, Gherkin, BDD (行为驱动开发), TDD (测试驱动开发), Anthropic, Claude 3.5 Sonnet, MCP (Model Context Protocol)
## Video description
Josh Guice - Principal Architect, Liatrio
See firsthand what it takes to extend AI-powered productivity from engineering to the rest of the organization. In this session, we follow a complete workflow end to end: a feature goes from a raw stakeholder conversation to fully scoped, developer-ready stories, with AI agents pulling in context from the team's existing docs and tools along the way. You'll watch every step and every artifact unfold on screen, and judge for yourself what it would take to get AI speed out of engineering and into the rest of the team.
[Source](https://www.youtube.com/watch?v=8yfiU0oUKzg)
Source quotes
[0:04] Josh Guice: 犯困场次（sleepy time session）
[0:04] Josh Guice: 从“灵光一闪”（Aha）到“收银入账”（Ching）
[2:27] Tom: 前台状况非常惨烈（front line's brutal）
[7:20] Sarah: 谢天谢地用的是测试信用卡
[10:41] Josh Guice: 将知识从人脑中外化并写入系统（Codifying Knowledge），是让 AI 工具发挥最大效能的前提。
[12:43] Josh Guice: 编写失败测试 -> 编写实现代码 -> 测试通过并重构
[12:43] Josh Guice: 看到自己操作产生的结果
[19:28] Josh Guice: Oh, this is a change that you did. Let's wipe that because I don't think that that functionality needs to exist.
Source quotes
[0:04] Josh Guice: from aha to cha-ching
[16:04] Josh Guice: Anything that gives AI a chance to validate the result of its own action, and check that it's done the right thing, is going to get you better results.
[16:04] Josh Guice: Codifying knowledge and getting it out of heads and into systems where AI can discover it to get better results.
Original transcript
[0:04] Uh I didn't realize this was the very last slot.
So, first off, thank you for making the trek
[0:09] all the way to the fifth floor for last
day of the conference, uh last talk,
[0:14] the sleepy time session. I'm going to
try to make this entertaining, hopefully,
[0:19] uh and informative, and uh
maybe a little bit enlightening.
[0:23] So, uh like she said, I'm Josh Geis. My
title is principal architect at Leathario.
[0:29] Uh but what I actually do anymore is uh work in
our innovation space. And so, that's innovation
[0:34] internally and innovation with our clients
doing enablement, hands-on, forward-deployed
[0:39] engineering, one-on-one pairing. That is my job
these days. Definitely uh time for a title update.
[0:47] So, uh today I'm going to tell
you a story, show you a story,
[0:50] about the agentic product development life cycle.
And uh if you watch the previous talk, a lot of
[0:55] that is going to resonate. It's it's like we've
uh we've been in the same mind mindset because um
[1:01] it's going to cover what happens before uh
work gets to development and how we can make
[1:07] the value stream more efficient by getting
clarity in that early part of the process.
[1:13] Uh so, this is going to look very familiar again
if you saw that slide. This is uh your typical
[1:18] value stream. And so, really any business can
be thought of as a series of value streams.
[1:23] You got some idea at the beginning, some, you
know, beginning of that process, and then you're
[1:27] building something that's hopefully of value
to somebody, and at the end you're shipping
[1:32] that value, and that that value is realized
by your clients, your customers, whatever.
[1:39] Uh as our CEO is fond of saying, from aha to
to ching. So, if you if you zoom in a little
[1:45] bit on that, uh you can break it down into some
smaller steps. These will look very familiar,
[1:50] things like listening to the market, listening
to your customers, doing some exploratory work,
[1:55] some research, validating those ideas,
defining, developing, you know, etc. So, today,
[2:03] um because there's so many threads and so many
levels to this, we're going to focus on just
[2:07] one segment of this, and it's just it's one piece
of the complex tapestry that this can be at your
[2:13] uh different enterprises and your different
environments. So, that part uh from exploration
[2:20] to validation, and we'll creep into development
a little bit is what we're going to focus on.
[2:27] There's a lot of different use cases
that this could apply to, as well.
[2:30] And uh these are all uh verticals in
the industry that Latrio works in.
[2:35] Today, we're going to focus on a simple one, just
start with a simple use case so you get the idea.
[2:40] And this is going to be uh a veterinary clinic,
and they need to add online payments. So,
[2:45] it's kind of an aging clinic, they
don't have online payments yet.
[2:50] This is the Emerald Grove Pet Clinic. And what
we're about to see is a meeting. They've already
[2:55] decided this is the right thing to do. We
want to add payments, um but now they need
[2:59] to talk about that the how. And so, like many
things uh like this, they start with a meeting.
[3:07] She has uh the AI assistant running. Transcription
uh is being recorded, so we can get context from
[3:13] the meeting because we're going to talk about
a lot of important things during the meeting.
[3:17] So, Dr. Carter, uh she's the
one that runs the clinic.
[3:21] She says pet owners keep asking
if they can just pay online.
[3:26] And Dan, the developer, he is worried about uh
compliance. So, if we're handling card data,
[3:32] uh that's something that's uh you know, introduces
some risk. So, we need to think about that.
[3:38] Lisa, uh the UX designer, just wants
to make sure it's really simple.
[3:43] So, they have uh you know, a variety
of clientele, and uh they want to
[3:47] make sure that everybody can use the new
payment system. It's really really easy.
[3:52] And Tom, the office manager, of course, uh he uh
he just wants the uh feature as soon as it can
[3:58] be shipped because front line's brutal. You
got these, you know, people waiting in line,
[4:02] dogs and cats fighting. It's kind of chaotic,
right? So, he just he needs it uh quickly.
[4:08] So, then Sarah, uh the hero in our story,
product owner, says, um "Okay, my AI agent
[4:13] has captured all this information. I've got the
transcript, and I am going to get a clickable
[4:18] prototype out today for everybody to review."
Yes, today. So, she heads back to her desk.
[4:29] And asks the AI agent to just process the
transcript and try to extract from that,
[4:34] you know, some outcome, some useful
context. What do we get out of that?
[4:38] So, the agent's processing the transcript and
starts extracting these outcomes and the specifics
[4:43] of what we're trying to build here. What's
important here, too, is that it's identifying
[4:48] who said what and tying it exactly to those
original statements. So, we want, uh you know,
[4:54] pet owners to pay for visits online. We're only
[snorts] going to focus on payments, not, uh you
[5:00] know, specialized food or anything like that. And
we want to make the checkout clear, like we said.
[5:06] And also, we want to make sure that we understand
our compliance obligations really clearly.
[5:11] Uh A decision in that meeting then is that
we should have a payment provider handle
[5:16] all of that. We need to outsource that. So,
now, uh she's got context from the meeting,
[5:22] uh but she can get some additional information
from some of the other systems that are in
[5:26] uh this this pet clinic. So, she tasks the
AI assistant to go um mining for additional
[5:33] context and enriching the work that she's about
to do with whatever it can find in these systems.
[5:40] So, it checks SharePoint and finds uh a
document about a a 2024 payment feature
[5:46] that was actually shelved. and so
somebody started this at some point before
[5:51] and ended up you know it didn't get finished.
That sounds like really useful context.
[5:56] It also finds a web accessibility policy. So to
understand how to build an accessible UI for this,
[6:04] that policy that has already been in place for
the rest of the website, it's important context.
[6:11] And then on to source control. And remember
it's the product owner doing all of this,
[6:15] you know, using her AI agent and
skills to mine all of this data.
[6:20] So of course it finds the code for the
clinic portal, it's the web app. Great.
[6:26] Uh but also the billing service. So the
billing service is a separate service.
[6:29] Okay, that's useful because that's probably where
we're going to integrate. And it finds the old uh
[6:36] pull request for the spike, the work that
was done for that 2024 payment feature
[6:42] that was shelved. There might be some really
good uh useful context and information in there.
[6:49] So then back to Sarah's desk, we assemble all of
this context into what we're calling a context
[6:54] brief. And what this is is it's like an index. So
it's got all the information about what was found
[7:01] and links back to the source so you've got this
provenance leading back to the original data.
[7:06] And that way um it's easy for AI to do
this progressive discovery of that context
[7:12] and the information that it's
going to need down the line
[7:14] when it's a brand new session
that's doing this work.
[7:20] So then great, and we've got all this. The
next thing is she's going to create uh a spike
[7:25] in Jira to track the work. This could be any work
tracking system. It doesn't have to be Jira, just
[7:30] Jira's a really common one so we picked that as
our example. So the AI agent is creating the spike
[7:36] and uh tracking that information about the
prototype that she's going to create cuz
[7:40] remember she said she'd build it today.
So now we move on to the validation.
[7:46] She's asking the AI assistant here to to
just build the prototype from all of this
[7:51] context that we've gathered and run the
prototyping skill uh on that spike data.
[7:57] So now on the left we've got uh her browser where
she's got just a simple payment taking form, you
[8:02] know, a V1 of this. And then [snorts] on the right
she has uh Slack. This could be Teams or any,
[8:08] you know, messaging system, of course. And she's
sharing the V1 out to get feedback in real time.
[8:14] Like [snorts] I said at the beginning, there's
a lot of different models of this. So this could
[8:17] be a a real-time collaboration. It could be an
async thing. There's a lot of ways to work this.
[8:25] So then Lisa, our uh UX designer, tries the
feature and uh she clicks it and nothing happens.
[8:32] So she clicks it again. She clicks it and clicks
it and clicks it. Nothing's happening. Is it
[8:36] even working? I don't know. So she sends Sarah a
message in Slack and said, "Hey, nothing happened
[8:44] when I did this. What's going on?" Uh Sarah
says, "Oh, yeah, I can see that. 57 payments.
[8:51] Uh a bit of money on the test credit card.
Thank goodness it was the test card."
[8:55] So she makes another round. And the point
of this is these are things that you might
[8:59] not find until you actually try to build
something and it hits the time dimension.
[9:03] If you're just looking at static mock-ups or
whatever, these things might not come to light.
[9:08] So she makes a V2. Shares that out. And
then Tom, the office manager, tries it.
[9:17] Like, okay, the button's disabled. Great. I
got a message. But how do I get a receipt?
[9:23] Clients are going to need a receipt. And
um also there's there's going to need to be
[9:27] some information in that receipt so they can
make insurance claims against those charges.
[9:34] So back to Sarah, message in Slack. Sarah says,
"Okay, great. I'll iterate with AI. Now, we'll
[9:42] we'll add this receipt capability and, you know,
provide some specifics that Tom told her about."
[9:50] So, V3 got a a receipt down there.
Looks good. Back to Tom. Tom tries it.
[10:00] Processes the payment. He gets a receipt. Came
to his email. Everything looks great. Okay, this
[10:05] is probably good, right? Like we've got enough
information now that we can build from this.
[10:14] So, back to Sarah and Tom sends her
message says everything looks good.
[10:19] Dr. Carter tries out the prototype. Says, "This
works great for me. Let's just get this built."
[10:25] Um this is probably a V1 that's going to go out
to production, maybe even behind a feature flag.
[10:30] So, it's something that can be pushed out.
The idea here is to do this in as small a
[10:34] batch as possible and iterate on it
even as we deploy it to production.
[10:41] So, now we're in the definition stage.
So, the next thing Sarah says is
[10:46] "Uh hey AI assistant, can you help me turn all
of this into stories with acceptance criteria?"
[10:54] So, back to Jira. You might notice that
there's a a BDD that's mentioned there.
[10:59] We'll get to that in a second if
you're not familiar with that.
[11:02] So, we close out the spike and now we
know how long that prototyping step took.
[11:07] Create an epic just as kind of a a feature
tracking buck uh bucket for the overall feature.
[11:13] And uh create a story for the checkout page.
We're going to start with the basic checkout page.
[11:19] So, in our description, we've got the
typical things that go into a story.
[11:23] Uh you know, Agile story format
as a I want so that sort of thing.
[11:29] But, also we have acceptance criteria. Now, if
you're not familiar, this is written in uh a
[11:34] domain-specific language called Gherkin, and this
[snorts] is part of the idea of behavior-driven
[11:39] development, which is to be able to express
acceptance criteria, or what a system should do,
[11:46] in a really natural language format. And
so, this is it's easy for anybody to read.
[11:50] And we've got a bunch of these.
There's just a few here as an example.
[11:55] What we're going to be able to do with that is
when we get to the develop stage, we'll be able to
[11:59] implement these tests, and anything that gives AI
a chance to validate the result of its own action,
[12:05] and check that it's done the right thing,
is going to get you better results.
[12:10] In addition, in this story, we have
uh the context brief attached. So,
[12:15] we've got all of that context that'll be
available to whatever system is executing this.
[12:21] Now, again, in the version that we're doing,
uh we're making it um kind of synchronous,
[12:27] one step at a time. This could be collaborative.
This could also be something that's picked up
[12:31] by an agentic platform, if you're
that far along in your fluency.
[12:37] So, we create the rest of the stories.
[12:43] And then we move on to develop.
So, now Dan developer's like,
[12:47] "Great, let's start with uh story three."
[12:52] He fires up his uh agentic CLI. This is no
particular branded one, but you get the idea.
[12:58] And you can see in there that he's
on a checkout page uh feature branch,
[13:02] and he's got some skills loaded, Spectrum
development, Jira, and SharePoint.
[13:09] Our Spectrum and development workflow
is something that we've open sourced and
[13:12] uh iterate on with our customers. You can
find that in our Leatrial Labs GitHub repo.
[13:17] That's the example I'm showing here. There's a lot
of different frameworks that can make this work,
[13:22] research, plan, implement, whatever.
The reason we came up with this one
[13:25] is because we wanted something that could
work the same across all of those tools.
[13:29] So you notice too when he invokes that skill
for spectrum development step one to generate
[13:35] the spec, he's providing some additional
instructions, too. Make sure that we get the
[13:40] behavior-driven development and we want to follow
test-driven development for this. So the system
[13:46] loads those skills, reads everything out of
the the Jira story, and great, got the context.
[13:54] Another thing our spectrum development workflow
does is ask clarifying questions. So if anything
[14:00] is unclear, then it asks the developer, "Hey,
can you explain this to me? Like how should we do
[14:04] this?" In this case, since we don't actually have
a payment integration yet, we're just going to
[14:09] stub that out. Like I said, probably we're going
to hide this behind a feature flag till we get
[14:15] something out there we can turn it on maybe for a
subset of users. Lots of ways to do that, right?
[14:21] So then the final step for the first phase is to
get that specification. So we've got our goals,
[14:29] we've got demoable units of work. That's again
that small batch approach that I mentioned.
[14:37] And then on to spectrum driven driven development
step two, which is to generate a task list
[14:43] from that specification. And that task list is
going to include the test-driven development,
[14:49] creating the behavior-driven development
scenarios. So we're going to implement that
[14:52] acceptance criteria in a codified way. There's
a whole theme here about codifying knowledge
[14:58] and getting it out of heads and into systems
where AI can discover it to get better results.
[15:05] And then spectrum development step three is to
just do the tasks. So it's going to write the
[15:10] tests. It's going to follow test-driven
development, the red green refactor.
[15:15] So it's going to write the test first, see it
fail, write the code, see it pass, and so on.
[15:24] And then we've added something that's not in a
lot of spectrum development workflows or workflows
[15:28] of this type, which is the step four where we
actually go back and validate the implementation.
[15:33] And this creates proof artifacts. So you see there
there's an MP4. That's actually a video of the
[15:39] system walking through the the checkout and making
sure that it does what it's supposed to. We've got
[15:44] our test reports and everything is part of that.
Again, these are ways to just keep AI on the rails
[15:51] and let it see the result of its own actions. It's
about fast feedback for the AI tooling as well.
[16:00] Everyone is pretty happy with that.
So we're going to call it a day.
[16:04] Our players are going to take a bow. And
they're going to do their best impression
[16:08] of the awkward Windows launch dance that
I could come up with with my AI tools.
[16:17] And that's it. I wanted to
leave time for questions.
[16:20] I don't know if we normally do
questions. [applause] Thank you.
[16:26] So uh quick one. Um so with the the example
you provided us, the product manager created
[16:34] a prototype. Yes. Then passed it along to the
engineer to then develop. Yep. I'm curious
[16:41] where you think the gap is in the skill set for
product managers currently that prevents them from
[16:48] doing the development. The last thing I'll quickly
call out, a lot of engineers throughout this
[16:54] conference have mentioned that junior engineers
will likely need to scale up from an architecture
[16:59] perspective. Yeah. And so I'm also curious how PMs
can develop that skill and kind of bridge the gap
[17:06] from prototype to strictly development. Yeah.
I mean one of the things that I've been working
[17:12] with PMs on really recently is just getting the
tooling set up and understanding how it works.
[17:17] And so that that is a a silly kind of gap, but
it's one that I've seen in in real customers.
[17:22] Uh the project managers were using Windows and
all the developers were on a Mac and they hadn't
[17:25] even really thought about getting it set up on the
Windows side. So it can be something as simple as
[17:30] that. Um there's a longer version of this that's
actually a 30-minute webinar that we did. It's on
[17:34] our website. You can go check it out. Uh there's
some steps in there that I cut out, but examples
[17:39] of the clarifying questions that that came back
in that example are things like um what retry
[17:44] approach should I use, you know, exponential back
like those are the kinds of answers I wouldn't
[17:48] expect a project manager to necessarily be able to
answer. So I think, you know, uh kind of echoing
[17:53] back to the previous talk about judgment,
that's still important and so you you need um
[17:58] scalability and security. I do think that those
guardrails are improving and becoming more
[18:04] automatic. So there's probably a point, uh you
know, at next year's AI 4 conference we'll have
[18:09] a different conversation about it. But I think
I think right now it's it's still necessary.
[18:14] Something that occurred to me very quickly, uh in
your example, does Sarah actually need to exist?
[18:21] I I ask this cuz immediately it was just if you
have an AI agent that's invited to a meeting,
[18:27] and like Copilot for example, it has uh the the
agent which can take notes through the summary.
[18:33] And then that agent that you're inviting to the
meeting has access to or has an email account,
[18:37] then instead of emailing Sarah, they can email
the agent and Sarah's job could transform from
[18:42] hey, does this agent have all the
tools it needs to do this task? Right.
[18:46] Yeah, there's a there's a more advanced version of
this where Sarah's job is quite a bit different. I
[18:50] think she still exists, but the role changes.
And she is more in touch with the customer.
[18:54] She's probably a true product owner, which we
don't see in a lot of our enterprise customers,
[18:58] where she really owns the roadmap for that
product and what the next features are.
[19:02] And she's prototyping with customers, maybe
even real time, to get that kind of feedback.
[19:06] Um I think what's uh what's important for her to
be in the mix for here, too, even at at level.
[19:12] And I I cut some of this out for time, but when
that context brief comes back, she's validating
[19:17] that this stuff makes sense. There's nothing
missing that she knows about that isn't in
[19:20] a SharePoint or a Confluence or whatever. So,
again, I think it's kind of we're moving in that
[19:25] direction, but we're not there yet. Well, if you
have like proper version controlling, couldn't you
[19:30] have the agent effectively do all the work on its
own? Yes. And she could go back through and go,
[19:35] "Oh, this is a change that you did. Let's wipe
that because I don't think that that functionality
[19:38] needs to exist." Right. And then what she can do
is basically build up the business context and go,
[19:43] "Hey, here's the business context agents. Can you,
you know, validate that everything you're doing is
[19:48] going through these?" Right. In a really advanced
version of this, you can have agents out doing
[19:53] research and market research and basically just
creating, if you're not worried about the token
[19:57] cost or, you know, that's something that you can
solve, just creating new versions for a product
[20:01] owner to try out or even for the customers to try
out. Uh there's a whole direction of uh you know,
[20:07] generative UI that happens on the fly.
Anthropic did a a demo of it when they
[20:11] released on it last year of William Shakespeare's
computer. And everything was generated in real
[20:16] time as you clicked. There There's quite
a bit of that happening. MCP applications,
[20:20] that new emerging standard is going
to drive some of that. So, again,
[20:24] I think we're not there yet, but it it's you're
forward-looking. Thank you. Yeah, you're welcome.
