Google's Osmani Binds Coding Agents to SDLC to Protect Production
Microsoft Developer
Production software requires strict, test-driven engineering guardrails because probabilistic AI agents introduce subtle system failures when teams rely on unstructured vibe coding.
Addy Osmani defines agent skills as portable, reusable bundles of engineering workflows, operational context, and domain guardrails that can be dynamically loaded into coding agents similarly to developer dotfiles. (0:06)
Rather than relying on unguided conversational prompting, Osmani structures agent skills around the traditional SDLC (Define, Plan, Build, Verify, Review, and Ship) to enforce engineering discipline and prevent cognitive surrender. (5:14)
Agent skills provide a major token economy advantage over standard Model Context Protocol (MCP) tool schemas by using progressive disclosure, exposing only a name and short description until an active task requires full instruction loading. (41:38)
For enterprise brownfield systems with active users, Osmani cautions against 'vibe coding,' arguing that nondeterministic model assessments must funnel into strict, deterministic testing gates and red-green TDD loops. (28:25)
Detailed notes
## Background
Published on June 5, 2026, by Microsoft Developer on YouTube as part of Microsoft Build 2026, this session features Addy Osmani and host Burke Holland. According to the page description, the discussion explores what agent skills are, how they encode senior engineering judgment into workflows for AI coding tools, and how developers can use them to achieve consistent, production-quality results.
## TL;DR
Addy Osmani breaks down how agent skills structure generative AI coding into disciplined workflows grounded in the six phases of the Software Development Life Cycle: Define, Plan, Build, Verify, Review, and Ship. Moving past informal 'vibe coding,' he demonstrates building a GitHub-style habit tracker using VS Code and GitHub Copilot, illustrating how structured skills enforce test-driven development, automated browser validation, and multi-pass code reviews. The session explores key trade-offs between speed and architectural rigor, detailing how progressive loading of skills conserves context budgets compared to heavy MCP tool schemas.
## Atmosphere & style
The presentation is conversational, collegiate, and peppered with lighthearted banter between two veteran web developers who share a history dating back to the early jQuery era. Burke's relatable self-deprecation about falling into cognitive surrender and getting hypnotized by spinning terminal agents balances Addy's methodical, Google-honed engineering discipline. Watching the stream feels like sitting in on a candid hallway track conversation where pragmatic industry war stories meet the cutting edge of AI-assisted engineering.
## Bulletin
- [00:06](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=6s) Addy Osmani defines agent skills as portable, reusable bundles of engineering workflows, operational context, and domain guardrails that can be dynamically loaded into coding agents similarly to developer dotfiles.
- [05:14](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=314s) Rather than relying on unguided conversational prompting, Osmani structures agent skills around the traditional SDLC (Define, Plan, Build, Verify, Review, and Ship) to enforce engineering discipline and prevent cognitive surrender.
- [41:38](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=2498s) Agent skills provide a major token economy advantage over standard Model Context Protocol (MCP) tool schemas by using progressive disclosure, exposing only a name and short description until an active task requires full instruction loading.
- [28:25](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=1705s) For enterprise brownfield systems with active users, Osmani cautions against 'vibe coding,' arguing that nondeterministic model assessments must funnel into strict, deterministic testing gates and red-green TDD loops.
## Key takeaways
- [00:06](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=6s) Agent skills serve as the modern equivalent of Unix dotfiles, allowing engineers to package and share repeatable workflows and domain-specific tricks across teams and codebases.
- [02:28](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=148s) Skills differ fundamentally from ad-hoc prompts because they represent formal, reusable assets designed to run across multiple projects rather than transient, single-turn interactions.
- [07:15](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=435s) Every standardized skill adheres to a four-part design pattern: activation rules, rationales (including negative guardrails), red flags, and verification criteria.
- [05:14](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=314s) Grounding agent skills directly in the traditional Software Development Life Cycle (SDLC) shifts AI usage from casual autocomplete toward disciplined, spec-driven engineering.
- [10:45](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=645s) Interactive interview skills (like `/refine`) interrogate vague developer ideas to establish constraints, target audiences, and non-goals before any code is generated.
- [14:14](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=854s) Blindly accepting a model's architectural preferences risks 'cognitive surrender,' making explicit specification documents crucial for retaining developer intent and agency.
- [20:47](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=1247s) The `/plan` phase decomposes large specifications into bite-sized engineering tasks with strict file boundaries to contain the agent's blast radius and avoid unintended regressions.
- [23:30](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=1410s) Codifying test-driven development (TDD) directly into build skills forces agents into a disciplined red-to-green loop, preventing untested code from reaching implementation stages.
- [26:32](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=1592s) While line-by-line code review becomes less practical during autonomous execution, engineers should inspect the agent's reasoning trajectory to ensure architectural alignment.
- [28:25](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=1705s) Greenfield prototypes tolerate casual, unguided vibe coding, but brownfield enterprise applications with active users demand rigorous automated verification rails.
- [31:16](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=1876s) Automated verification skills execute real builds and leverage headless browser tooling (such as Playwright or Puppeteer) to confirm runtime UI behavior rather than relying solely on static inspection.
- [33:27](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=2007s) Code simplification loops represent a major underutilized capability of coding agents, enabling teams with comprehensive test suites to safely refactor and clean up working code.
- [35:46](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=2146s) Probabilistic LLM security scans excel at detecting subtle edge cases and XSS risks, but they must ultimately be paired with deterministic quality gates for critical production safety.
- [40:08](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=2408s) Cost and performance can be optimized across multi-model workflows by delegating high-level planning to lightweight 'Flash' models and hands-on implementation to high-capacity 'Pro' models.
- [41:38](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=2498s) Many agent workflows are faster and more direct when pairing skills with existing CLIs rather than building complex, granular MCP servers, though MCP remains valuable for enterprise auth and live documentation ingestion.
## Detailed walkthrough
### [00:06](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=6s) Introduction, Early Web Days, and the Dotfiles Analogy
Burke Holland welcomes viewers back to the broadcast stage, introducing Addy Osmani as a Director of Google Cloud AI, best-selling author, and longtime authority on AI developer experience and user experience. Burke shares a lighthearted anecdote about watching a recent Bloomberg feature on artificial intelligence, excitedly pointing out to his wife that he knew Addy, only for her to dismissively respond that he didn’t. The two reflect on their shared history stretching back to the early jQuery era and the evolution of frontend engineering from browser web performance optimizations to modern agentic systems. When Burke mentions that Addy’s recently published agent skills repository landed on the front page of Hacker News multiple times, Addy jokes, “I try not to look at Hacker News too much these days. You never know if it's going to be good or bad.”
Addy explains that agent skills represent a standardized mechanism for supplying AI agents with new capabilities, domain expertise, and operational context. To illustrate their practical role, he compares agent skills to the classic developer tradition of sharing dotfiles and custom shell configurations. In that era, engineers would share their personal setup files as a curated collection of shortcuts, shell aliases, and workflow automations. In the same way, agent skills function as a portable toolkit that other practitioners can adopt wholesale, dissect for inspiration, or tailor to match their specific engineering practices.
- **Addy Osmani's role**: Director of Google Cloud AI, working on core agent technologies including the Agent Development Kit, the Agent Platform, and enterprise agent skill initiatives.
- **The dotfiles parallel**: Just as developers shared personalized Unix dotfiles to distribute productivity hacks, agent skills package repeatable workflows and domain-specific tricks for AI agents.
[02:28](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=148s) The Clippy Demo and the Anatomy of an Agent Skill
To set up the demonstration environment, Addy presents a custom browser interface he “vibe-coded”—a humorous, Frankenstein-like operating system interface running a classic Windows desktop complete with Microsoft Clippy placed directly above an Apple macOS dock. Burke jokes that combining those two interface paradigms delivers “the worst of all worlds,” while cautioning Addy about strict internal event guidelines: “There actually is a Clippy suit. There is a wear, but if you wear it, you're not allowed to speak. True story.”
```mermaid
flowchart TD
accTitle: Agent Skill Architecture and Runtime Loading
accDescr: How an incoming user task matches a skill definition and triggers workflow execution.
subgraph Meta ["Skill Definition (Metadata)"]
A["Skill Name"]
B["Skill Description"]
end
Meta --> D
C --> D
D -->|"Matches description"| E
E --> F
```
Transitioning into the mechanics of agent skills, Addy explains that at their core, skills package workflow instructions, operational context, and specialized knowledge that an underlying foundation model does not inherently possess. Structurally, every skill file relies on two foundational properties: a descriptive name and an intent description. Unlike one-off conversational prompts, which are engineered for transient interactions, skills are built to be reusable assets shared across an entire engineering team and executed across multiple projects. At runtime, the agent only inspects the skill’s top-level name and description until a task specifically demands those capabilities, at which point the agent pulls the complete workflow instructions into its active context.
- **Core schema components**: Every skill file fundamentally exposes an explicit name and description, which the orchestrating agent queries on demand.
- **Prompts vs. skills**: Prompts serve ad-hoc, disposable tasks, whereas skills represent formalized, repeatable engineering workflows across repos and teams.
- **Dynamic context injection**: The agent does not bloat its baseline context window with every skill instruction simultaneously; it dynamically matches incoming tasks to skill metadata and loads procedural steps only when invoked.
[04:14](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=254s) Open Source Motivation and Garry Tan's gstack
Addy outlines the personal origins of the project, noting that he had deliberately dialed back his open-source commitments over the prior few years. “As you know, you create an open source project, it's a lot like having a kid. You have to maintain it,” Addy observes, highlighting the deliberate decision-making required before introducing a new public codebase.
The spark to release his own skills repository came after observing Garry Tan publish `gstack`. Seeing how developers latched onto Tan’s workflows convinced Addy that releasing an alternative, engineering-centric perspective would provide value to the broader development community. He decided to open-source his personal framework, which immediately gained significant traction among engineers experimenting with autonomous and semi-autonomous coding assistants.
[05:14](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=314s) Grounding Agent Skills in the SDLC
Addy differentiates his agent skills from other community offerings by anchoring every skill directly into the traditional Software Development Life Cycle (SDLC): Define, Plan, Build, Verify, Review, and Ship. Rather than viewing generative AI as an unstructured autocomplete engine, he treats it as a disciplined partner in agentic and AI-assisted engineering. “I ground my agent skills around the software development life cycle,” Addy emphasizes. “I think that they're, you know, I, I lean very heavily into agentic engineering, AI assisted engineering, that side of things where you try to be very disciplined about, you know, I'm going to be explicit about what I want built. I'm going to verify what gets built. I'm going to keep quality in mind.”
```mermaid
flowchart LR
accTitle: SDLC-Aligned Agent Skills Workflow
accDescr: The six sequential phases of Addy Osmani's SDLC agent skills framework.
subgraph Discovery ["1. Discovery & Planning"]
D["Define<br/>• Clarify vague ideas<br/>• Spec-driven dev"]
P["Plan<br/>• Task breakdown<br/>• Architecture"]
end
subgraph Implementation ["2. Execution & Testing"]
B["Build<br/>• UI design<br/>• Clean API contracts"]
V["Verify<br/>• Headless browser tests<br/>• Auto-debugging"]
end
subgraph Delivery ["3. Quality & Deployment"]
R["Review<br/>• Simplification<br/>• Security scans"]
S["Ship<br/>• Git workflows<br/>• CI & documentation"]
end
D --> P
P --> B
B --> V
V --> R
R --> S
```
Under this model, each phase of development contains specialized skills designed to prevent AI hallucinations and poor technical compromises:
- **Define**: Interactive interview skills that take rough shower thoughts or incomplete feature ideas and interrogate the developer until they yield an unambiguous product specification (spec-driven development).
- **Plan**: Translation skills that convert architectural specs into actionable, bite-sized tasks.
- **Build**: Implementation skills focused on clean frontend UI generation, consistent component boundaries, and robust API contracts.
- **Verify**: Autonomous browser-based UI validation and automated debugging workflows, drawing heavily on Addy’s prior background on the Google Chrome engineering team.
- **Review**: Multi-pass code evaluation loops targeting unnecessary complexity, architectural drift, and security vulnerabilities.
- **Ship**: Deployment automation covering Git staging, changelogs, continuous integration checks, documentation generation, and release management.
[07:15](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=435s) Internal Skill Design Patterns and the VS Code Copilot Setup
Addy explains the internal blueprint applied uniformly to every skill inside his repository. Rather than handing raw markdown prompts to a language model, each skill contains a standardized four-part anatomy designed to keep non-deterministic models operating within safe operational parameters:
1. **Overview & Activation Rules**: Explicit statements indicating exactly under what conditions the skill should be engaged.
2. **Rationalizations**: Clear arguments explaining both why the skill should be applied and why it should explicitly *not* be used for certain tasks, creating negative guardrails.
3. **Red Flags**: Concrete early warning indicators alerting the agent when an implementation or debugging attempt has drifted off track.
4. **Verification Steps**: Strict exit criteria and automated assertions required to prove that the task was executed correctly.
To demonstrate these patterns in practice, Addy opens an integrated VS Code workspace containing his scaffolded project. The repository structure includes an `.agent` directory alongside predefined prompt files that surface these skills directly within GitHub Copilot. Addy selects Gemini 3.5 Flash as the underlying reasoning engine in the Copilot chat sidebar, noting its strong performance profile for agentic coding and sequential reasoning tasks. Each installed skill automatically registers as a native slash command (such as `/refine` or `/simplify`), allowing developers to invoke structured SDLC procedures straight from the chat panel before pivoting into a practical test-driven development workflow.
[09:20](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=560s) Structuring TDD and Engineering Judgment into Skill Files
Addy Osmani walks through the internal structure of the skill files, noting that while there is a substantial amount of content packed into each file, every line is carefully considered to prevent unnecessary context-window bloat. Developers are free to trim or optimize the skills, but Addy prefers being very explicit about expectations. In his test-driven development (TDD) skill, he encodes the core TDD cycle—defining clear criteria for what constitutes a failing test, what constitutes a passing test, and how refactoring should be approached.
```mermaid
flowchart TD
accTitle: TDD Skill Structure
accDescr: Shows the components of Addy Osmani's TDD agent skill including cycles, best practices, and guardrails.
subgraph Safeguards["Engineering Guardrails"]
C["Test Anti-Patterns to Avoid"]
D["Security Boundaries"]
E["Browser Testing & Debugging"]
end
CoreTDD --> Safeguards
```
Much of this guidance is drawn directly from engineering practices used at scale inside Google. The skill incorporates the testing pyramid, concrete decision guides, explicit anti-patterns to avoid, security boundary checks, and browser-specific debugging hooks to connect with downstream testing workflows. As Addy explains: “I try to be explicit just because I think that there's value to being intentional with how you approach these things.”
- Skill definitions explicitly establish the semantic difference between passing and failing tests.
- Contains the classic testing pyramid alongside decision trees for choosing test types.
- Specifies test anti-patterns and concrete pitfalls to prevent flaky assertions.
- Maps security boundaries and browser testing rules directly into agent context.
[10:45](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=645s) Starting the Habit Tracker: The `/refine` Phase
Shifting into a practical demonstration, Addy shares that he has spent much of his life trying to optimize personal productivity—admitting with a laugh that he has probably failed at it a lot. Because habit tracking is a perennial developer topic, he proposes building a habit tracker app inspired by the visual aesthetic of the GitHub contributions graph. To demonstrate the power of the skills framework, Addy initiates the process with an intentionally vague prompt: building a GitHub-inspired habit tracker stored entirely in the browser without any database backend. Burke Holland asks whether Addy plans to explicitly specify a contribution graph in the prompt, but Addy decides to omit it to see whether the skill can deduce the intent on its own.
```mermaid
flowchart LR
accTitle: Idea Refinement Flow
accDescr: The refinement skill takes a vague prompt, queries the user with targeted questions, and produces structured directions.
A["Vague User Prompt<br/>'GitHub-inspired habit tracker'"] --> B["/refine Skill Execution"]
B --> C{"Clarification Questions<br/>(Audience, Storage, Scope)"}
C --> D["3 Strategic Directions<br/>(A, B, C)"]
```
Addy runs the `/refine` slash command, which reads the refinement skill into the model's context. Rather than jumping straight into generating code, the agent immediately halts to ask targeted clarifying questions:
1. Who is the primary target user? (Addy specifies an audience of software engineers at Build or watching later on YouTube).
2. What are the constraints and expectations for browser-only storage? (Addy opts for standard `localStorage` rather than IndexedDB or session storage to keep it simple).
3. What GitHub analogies should be explored beyond the standard contribution grid? (The model asks about committing habits, branching variations, or pull requests; Addy prefers not overcomplicating things and keeps it focused strictly on the contribution grid).
4. What does success look like for the MVP? (Addy passes on complex offline-first service worker setups, stating: “Load fast and have a clean UI be responsive.”)
[14:14](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=854s) Strategic Directions, Cognitive Surrender, and Finalizing Scope
Once the clarifying answers are submitted, the agent generates a structured problem statement alongside three distinct product directions:
| Direction | Concept | Characteristics |
|:--- |:--- |:--- |
| **Direction A** | Dev Profile Configurator | A minimalist, high-fidelity clone of a GitHub profile that tracks habits like repositories. |
| **Direction B** | Habit Terminal (TUI) | A keyboard-driven, terminal-style interface for entering daily completions. |
| **Direction C** | Markdown/SVG Exporter | A data-centric, plain-text backend tool managing raw habit data and configurations. |
Burke jokes that TUIs (terminal user interfaces) are “so hot right now,” but Addy selects Direction A, naming the application "Streak." Burke asks whether the model explicitly recommended one of the choices, noting that models often nudge developers toward a specific option: “Because I notice models like to recommend and they almost always when they give you choice and be like, well, this is what I do... And then I'm like, well, if that's what you do, then that's what I want to do.” Burke laments falling into this trap, admitting that blindly trusting the model's preference feels like losing agency. Addy agrees, teasing: “I have so much to say about cognitive debt and cognitive surrender.”
The skill captures assumptions that need validating—such as retention rates, mobile usability (since developers configure setups on desktops but mark habits complete on mobile devices), and whether `localStorage` is sufficient. It explicitly lists non-goals, ruling out cloud sync and social features, before saving the refined document as a markdown asset.
[17:15](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=1035s) Moving from Refinement to the `/spec` Phase
With the high-level concept saved, Addy moves to the next life-cycle stage: the `/spec` command. Burke comments on the layered nature of this approach, noting that some developers might feel like it introduces extra steps, whereas he prefers a direct "plan and implement" flow. Addy acknowledges this difference in style: “You don't have to follow my way of doing things. If you want to just have like one step for creating your spec, you can do that. I just happen to like specificity.”
```mermaid
flowchart LR
accTitle: Refine to Spec Transition
accDescr: Output from the refine step is ingested by the spec skill to construct a technical architecture.
A["Refined Idea Doc<br/>(Scope, Non-goals)"] --> B["/spec Skill"]
B --> C["Technical Specification<br/>(Architecture, UI Decisions)"]
```
Running `/spec` consumes the output file from the refinement step, scaffolding out the exact technical stack, concrete success criteria, and implementation questions. Burke remarks that the execution is “really snappy,” and Addy points out that rapid inference models like Gemini Flash make these multi-turn elicitation workflows feel seamless. As the specification generates, the agent surfaces technical design decisions, such as whether to render the contribution grid using modular dynamic SVGs or CSS grid elements. Not wanting to get bogged down in SVG arcana, Addy instructs the agent to pick whichever layout approach it thinks is best before tackling the first-visit onboarding experience.
[19:01](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=1141s) Defining Default Habits and Generating the Specification
The conversation turns to establishing default sample habits for first-time visitors using the habit tracker. Burke Holland asks whether they should track good habits or bad habits. Addy Osmani clarifies that they are tracking positive behaviors, leading to a quick brainstorm of defaults: exercise, hydration, reading, and meditation. Burke jokingly tosses in “doomscrolling,” which Addy quips might require meditation right after. When prompted by the Copilot agent for a preferred file location, Addy defers to the agent's default judgment. He highlights how convenient it is that the entire interaction happens directly within the sidebar without needing to jump out into a separate web app or interface: “Whatever your agentic UI surface is, you can just have a similar experience there.”
```mermaid
flowchart TD
accTitle: Spec Generation and Technology Assumptions
accDescr: The agent collects user habit inputs and uses encoded skills to generate a comprehensive spec file with metrics, test framework, and tech stack.
subgraph Inputs["Interactive Clarification"]
A["Default Habits<br/>(Exercise, Hydration, Reading, Meditation)"]
B["Target File Location<br/>(Agent Default)"]
end
subgraph SpecGeneration["Spec Generation Skill"]
C["Comprehensive Spec File"]
D["Performance Targets<br/>(Largest Contentful Paint)"]
E["Encoded Assumptions<br/>(Vanilla JS, Vitest, Playwright, LocalStorage)"]
end
Inputs --> C
C --> D
C --> E
```
The agent converts the requirements into a structured, highly detailed specification file that expands significantly on their initial concept. The generated spec establishes concrete success criteria, performance targets like Largest Contentful Paint (LCP), and architectural defaults. Burke notices that the agent chose vanilla JavaScript without asking about frameworks, prompting Addy to explain that encoding sensible defaults directly into agent skills saves time when you don't explicitly require tools like React.
- **Default habits selected**: Exercise, hydration, reading, and meditation (with a running joke about doomscrolling).
- **Core tech stack assumed**: Vanilla JavaScript, LocalStorage for persistence.
- **Testing stack assumed**: Vitest for unit tests, Playwright for end-to-end testing.
- **Customizability**: Any generated detail or technology constraint can be modified manually or refined conversationally with the agent.
---
[20:47](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=1247s) Decomposing Specifications into Granular Implementation Plans
Once the specification is locked in, Addy moves to the `plan` step to break the project into manageable engineering tasks. While small one-off scripts can jump straight to code generation, larger projects benefit from structured decomposition. Breaking large problems into smaller chunks mirrors classic software engineering principles and maps cleanly onto test-driven development (TDD), providing isolated, verifiable checkpoints throughout development.
```mermaid
flowchart LR
accTitle: Plan Decomposition and Task Structure
accDescr: The Plan skill breaks down the broad project spec into distinct phases, acceptance criteria, and specific target files.
A["Overall Project Spec"] --> B["Plan Skill Execution"]
subgraph PlanOutput["Plan Output (plan.md / Task List)"]
C["Phase 1: Pure Logic & Types<br/>(Streaks, 365-day calc, LocalStorage)"]
D["Phase 2: Data Storage Layer"]
E["Phase 3: Visualization & Graph UI"]
end
B --> PlanOutput
C --> F["Acceptance Criteria & Vitest Suites"]
C --> G["Targeted File Scoping<br/>(Blast Radius Control)"]
```
The agent scaffolds the initial repository boilerplate and creates a structured task list inside the plan documentation. Phase 1 targets the pure business logic: TypeScript interfaces, type definitions, streak calculation math, 365-day rolling contribution totals, and LocalStorage helpers—deliberately keeping UI concerns isolated. Each task includes strict acceptance criteria, a designated test suite verification gate, and explicit target file lists. Limiting the blast radius prevents the agent from modifying unrelated files, an essential guardrail when dealing with complex or existing codebases.
- **Blast radius containment**: Scoping tasks to specific files prevents regressions and unwanted overwrites across the repository.
- **Phase 1 scope**: Pure domain logic and calculations completely decoupled from the DOM.
- **Verification criteria**: Every planned task must have a passing automated test suite before being considered complete.
---
[23:30](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=1410s) Executing Test-Driven Tasks and Managing Developer Interventions
Addy demonstrates task execution using the `/build task 1` command. The agent reads the project's internal TDD skill and begins setting up dependencies. Burke points out a toggle at the bottom of the interface for bypassing approval prompts on shell commands, a feature Addy is surprised and delighted to discover. Burke admits his own approach: “I bypass approvals on all my personal projects.”
```mermaid
flowchart TD
accTitle: TDD Build Loop Execution
accDescr: The agent runs through the Red-Green TDD cycle for Phase 1 by writing failing tests and then minimal code to pass them.
A["/build task 1 Triggered"] --> B["Load TDD Skill"]
B --> C["Write Failing Unit Test<br/>(Red)"]
C --> D["Implement Minimal Logic in Streaks module<br/>(Green)"]
D --> E["Run Vitest Suite Verification"]
E --> F["Complete Task 1 / Advance Plan"]
```
Burke asks whether Addy typically builds applications one phase at a time or prefers letting the model tackle the entire application in a single pass. Addy explains that it depends on the nature of the project. For throwaway side projects, generating everything at once is fine; but for larger, production-oriented systems, step-by-step verification brings sanity and reliability: “It might feel like it's slower, but the fact that you go through all of these steps and you know, well, this slice is tested as we build out the UI I know nothing else is broken.” Burke notes the psychological trade-off of human-in-the-loop workflows: “It's such a trade-off though because then you know the back in the loop, like once again, you're the problem. You're slowing the agent down.” Addy emphasizes that developers must decide where to spend their cognitive effort:
> “And I would say that, you know, you have to make a judgement call at the end of the day about how much time you want to invest in where in the software development life cycle you want to invest it.”
- **Development workflow trade-offs**: Heavy upfront spec and review vs. incremental, test-driven red-green phases.
- **TDD loop in action**: The agent first writes a target failing red test, then writes the minimal clean code needed to achieve green.
- **Approval ergonomics**: Enabling bypass mode speeds up execution when the developer is comfortable with autonomous tool calling.
---
[26:32](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=1592s) Developer Attention, Trajectory Reading, and Code Comprehension
As the build loops through tests and implementation details, Burke and Addy explore how developers actually spend their time while an agent is actively executing. Burke confesses his own habit of being mesmerized by the tooling: “Now, I'm not reading everything that it's doing. I'm mostly just staring at it when I should be doing something else. But I'm just, I'm literally watching agents spin.” He asks Addy whether he actually reads the generated code line by line.
Addy reflects on how his own habits have evolved. Rather than multitasking or blindly reviewing code output, he focuses on the agent's internal reasoning and step-by-step trajectory to ensure its architectural intuition aligns with his expectations:
> “And these days I try to read the trajectory a little bit more like what did it say? What was it thinking? Why was it thinking what it was thinking? And is there any nugget of information in there that I can extract that just lets me know? Oh, OK. Well, that was the way I was expecting.”
Addy distinguishes between short-lived scripts and long-term software. For disposable utilities needed for an hour, he lets the agent handle errors autonomously without deeply studying the implementation. But for systems intended to be maintained for weeks or months, he deliberately studies the architecture and inspects core modules so that when the agent eventually derails or hits an edge case, he retains the domain knowledge needed to step in and fix it manually. The build loop continues progressing through the TDD slices as the foundation is established.
[28:25](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=1705s) Red-to-Green Testing and the Realities of Agentic Engineering
Burke Holland marvels at the mechanics of test-driven development, remarking that he had never encountered red-green testing until GitHub Spec Kit was released, despite having spent decades in tech. As Burke jokes about discovering the practice of intentionally writing failing tests before making them pass well into his forties, Addy Osmani reflects on how the broader agentic engineering ecosystem often oversimplifies development workflows. Advice circulating across social media typically caters to solo founders or early-stage startups hacking away on greenfield, evergreen codebases without an active user base. In those low-stakes environments, relying on pure "vibes" and letting an AI agent guess its way through errors can be completely acceptable. However, teams maintaining brownfield legacy software with active users face a completely different reality where engineering rigor and deep understanding of what happens under the hood remain non-negotiable.
Burke emphasizes that many practitioners are actively searching for a magic bullet—wondering whether they should install Agent Skills, Superpowers, or G-Stack—only to realize that software development is shifting fundamentally. The modern role is becoming less about manually authoring code and far more about orchestrating dependable workflows that match the bespoke needs of specific codebases. Joking about whether developers are turning into management consultants, Burke asks how to characterize this shift. Addy frames software construction as a spectrum between casual vibe coding and disciplined agentic engineering. As Addy Osmani states, “And I think that at big companies, small companies, anytime that you're working on something that exists and has existing users, you owe it to them to care about quality, to care about not breaking things in ways sometimes agents subtly do.”
- **The Greenfield vs. Brownfield Divide**: Casual prototyping allows developers to hand off full autonomy to agents, whereas production enterprise code requires explicit rails to avoid subtle regressions.
- **Workflow Orchestration**: Developer responsibilities are tilting from line-by-line syntax writing toward architecting repeatable verification and implementation pipelines.
[31:16](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=1876s) The Verify Phase and In-Browser Agent Testing
Transitioning into the operational pipeline, Addy demonstrates the Verify skill included in the Agent Skills package. The purpose of this phase is to evaluate whether the application—even when only partially implemented—can actually compile, boot up, and perform its intended functions inside a live execution environment rather than merely looking correct in source code. Within VS Code, the agent triggers an `npm run build` followed by `npm run dev`, launching an embedded browser directly inside the editor to inspect the generated user interface. When the app renders an authentic-looking GitHub profile layout, Burke and Addy are momentarily derailed by the avatar image the LLM conjured up out of nowhere, joking about whose face it might be and whether it belongs to a random baker who simply happens to have a GitHub account.
Once the preview boots, the verify skill runs diagnostic checks behind the scenes to verify that DOM interactions work without throwing errors or breaking the interface. Addy highlights that the agent leverages automated browser workflows, pointing out that developers have an abundance of modern tooling choices—such as Puppeteer, Playwright, or Vercel's agent browser—to automate visual and behavioral checks. Burke observes that web developers enjoy a significant tooling advantage over native mobile and desktop developers when it comes to automated headless browser testing. Addy underscores that teams can decide how far they want to take these automated checks, from simple smoke tests to exhaustive end-to-end user journey validations.
```mermaid
flowchart TD
accTitle: Agent Skills Verification and Review Pipeline
accDescr: Pipeline showing build, headless browser verification, multi-pass review, and simplification loop.
subgraph VerifyPhase["Verify Phase"]
A["Compile Code (npm run build)"] --> B["Start Dev Server (npm run dev)"]
B --> C["Embedded Browser Smoke Test (Playwright / Puppeteer)"]
end
subgraph ReviewPhase["Review & Refinement Phase"]
C --> D["Multi-Pass Review (Security, Correctness, Architecture)"]
D --> E["TDD Simplification Loop"]
E -->|"Verify against unit tests"| D
end
```
[33:27](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=2007s) The Review Phase: Multi-Pass Code Review and Simplification
The pipeline next moves into the Review phase, an area where Addy notes engineering cultures hold passionate and varied perspectives. Even at Google, where peer review remains firmly rooted in manual human assessment, implementing an automated, local multi-pass review before code reaches a human reviewer provides immense leverage. Some teams even employ adversarial review patterns by enlisting independent models—for example, deploying Google Gemini for the initial implementation and an Anthropic Claude Opus or OpenAI Codex model to interrogate the pull request for blind spots.
In this demonstration, the review skill runs a suite of specialized checks over the habit tracker codebase:
| Review Category | Focus Area & Assessment |
|:--- |:--- |
| **Correctness** | Verifies that all implemented unit tests pass without failure. |
| **Security** | Scans vanilla JavaScript for common vulnerabilities, including Cross-Site Scripting (XSS). |
| **Readability & Architecture** | Evaluates code cleanliness, modularity, and structural coherence. |
| **Performance** | Confirms runtime efficiency and lightweight footprint for simple client-side execution. |
| **Accessibility Recommendations** | Suggests usability enhancements, such as adding keyboard navigation to the contribution graph grid. |
Beyond initial critique, Addy highlights code simplification as one of the most underutilized applications of agents. Developers frequently accept an agent's initial working draft without asking if the implementation could be streamlined. As Addy Osmani explains, “And one of the wonderful things about TDD or having tests or quality gates around is that you can now go and do that code simplification loop and have something that can verify the rest of your logic still works.”
[35:46](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=2146s) Nondeterministic Security Checks and Deterministic Quality Gates
Burke raises a critical concern regarding the nondeterministic nature of LLMs, questioning how much faith developers can realistically place in an AI model's security sign-off when vulnerabilities like SQL injection or accidental API key leaks carry catastrophic consequences. Burke admits to being terrified of sharing projects publicly on social media only for someone to immediately expose a hardcoded API key in the comments. Addy acknowledges the gravity of the risk, pointing out that anyone spending time in the vibe-coding ecosystem has witnessed developers deploy terrible authentication patterns, cause massive data leaks, or leave unprotected endpoints completely open to rate-limit exhaustion.
While specialized static analysis tools and enterprise security suites go deeper, Addy argues that codifying senior engineering rules into skills serves as an indispensable safety net against human exhaustion and inexperience. LLMs excel at systematically combing through codebases to surface obscure edge cases that developers routinely overlook. However, Burke maintains that probabilistic AI assessments should ultimately funnel into strict, deterministic gates that verify absolute safety before production deployment. As Burke Holland puts it, “Because to me, this is where the rubber meets the road, right? The rest of this stuff you can deal with. The security stuff cannot.” In response, Addy stresses that the ultimate strength of agent skills lies in forcing teams to explicitly articulate what "good" and "done" actually mean across security, performance, accessibility, and architectural quality.
[38:05](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=2285s) Quality Gates, Nondeterminism, and the Completed Streak App
Addy Osmani emphasizes that having explicit tooling in place prevents code from being merged against engineering best practices, noting that skills are simply one structured mechanism for establishing quality gates. Burke Holland responds with a humorous observation about the current state of developer tooling, noting: “It's like, well, we have nondeterminism. How are we going to fix that with more nondeterminism with text files, With text files.” Addy explains that whenever leading engineering labs open-source their research or publish write-ups on code simplification, he studies their workflows to incorporate those techniques directly into his agent skills. Even within the simple demonstration app, the simplification skill immediately identified three or four distinct opportunities to streamline the codebase.
```mermaid
flowchart TD
accTitle: Progressive Skill Loading Flow
accDescr: Diagram showing how agent skills load progressively into context compared to heavy MCP tool schemas.
subgraph Discovery["1. Discovery Phase (Minimal Tokens)"]
A["Agent Context"] --> B["Skill Name & Short Description"]
end
subgraph Activation["2. Progressive Activation"]
B --> C{"Matches Task?"}
C -->|Yes| D["Load Full Skill Instructions"]
C -->|No| E["Omit from Context"]
end
subgraph Execution["3. Execution & Deep Dives"]
D --> F["Reference Specific Files / CLIs"]
F --> G["Execute Workflow Tasks"]
end
```
With approximately six minutes left in the session, Addy skips ahead past the final shipping step to showcase a pre-built reference application called "Streak." The app features a GitHub-style contribution graph positioned at the bottom of the interface to track personal habits over time, such as taking screen-free morning hours, planning daily work goals, and completing daily reflection. Demonstrating the project's architecture, Addy opens the browser's developer tools to the Application panel under Local Storage, proving that all entry data persists entirely on the client. The application is completely local and functions offline without external backend complexity, successfully fulfilling the core requirements of the MVP.
- The habit tracker app "Streak" records habits like morning screen-free time, workday goal setting, and daily reflection.
- All application state and streak entries persist offline via client-side `localStorage`.
---
[40:08](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=2408s) Multi-Model Workflows: Planning with Flash vs. Implementing with Pro
Burke transitions the session into audience Q&A, taking a question from an attendee named Anthony regarding how to allocate tasks between smaller "Flash" tier models and larger "Pro" tier models. Anthony asks whether it makes sense to handle high-level planning in a Flash model and switch to a Pro model for hands-on code implementation. Addy strongly endorses this division of labor, pointing out that it is his exact day-to-day workflow, particularly when optimizing for token consumption and operational costs.
Addy outlines that lower-cost, lightweight models are well-suited for high-level planning phases where broad structure and outlines are generated. Once the plan is established, developers can hand off implementation to higher-capacity models such as Gemini Pro, Claude Opus, or specialized coding models. He notes that modern developer environments like GitHub Copilot allow engineers to toggle smoothly between underlying models depending on which phase of the development life cycle they are executing.
> “You can use a lower cost model often for the planning phase, especially if you're trying to like optimize for tokens, use a lower cost model for the planning phase, use a much more capable model for your implementation.” — Addy Osmani
---
[41:38](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=2498s) Agent Skills vs. MCP: CLI Efficiency, Progressive Loading, and Context Budgets
Burke pivots the conversation to the Model Context Protocol (MCP), asking Addy where MCP fits into skill-driven workflows. Addy admits he holds strong opinions on the topic, observing that while MCP initially gained traction for connecting data sources to agents, the industry is discovering that exposing agents directly to standard Command Line Interfaces (CLIs) is frequently faster and more direct. Rather than exposing numerous granular tools over MCP servers, letting the agent invoke CLI commands often reduces friction. Burke concurs, recalling his own controversial assertion that many MCP servers should just be a skill paired with a CLI because LLMs are remarkably adept at operating terminals.
Burke acknowledges a key counter-argument raised by Reese at OpenCode: CLI execution struggles with fine-grained agent permissions and security boundaries, whereas MCP handles authentication and access controls cleanly. However, Burke reveals that outside of internal enterprise data tools like Work IQ (within the Microsoft ecosystem) and Context7 (an MCP server used to ingest live documentation prior to generating code), he relies almost entirely on agent skills. Addy adds that Google Cloud and other teams are increasingly maintaining specialized skill packs because they ensure the agent has up-to-date instructions and accurate workflows regardless of the model's training cutoff date.
Burke highlights the architectural advantage of agent skills over MCP: progressive loading. In standard MCP setups, the full schema definitions for all available tools must be packed into the context window upfront, rapidly exhausting context budgets. In contrast, skills expose only a name and a concise description until the model actively selects them, at which point detailed instructions and referenced files are pulled in on demand. Burke stresses that managing tokens carefully is becoming critical as development shifts from unlimited AI usage to strict token quotas:
> “So what the model gets is like the skill name and a brief description. And then from that it then will load in the skill. And then the skill may point to other files and then it will load in those files. And so it's just really, really economical for token usage, which is more important now. It's becoming more important every day as we are moving from a world of use as much AI as you want to to this is how many tokens you have. Use them wisely.” — Burke Holland
- **CLI vs. MCP trade-off:** CLIs provide efficient execution paths that agents naturally handle well, but MCP provides structured authentication and permission controls.
- **Context7 MCP:** A recommended MCP server that forces agents to fetch and read up-to-date framework documentation before writing code.
- **Work IQ:** A critical MCP server for developers embedded within the Microsoft enterprise ecosystem.
- **Progressive Disclosure:** Skills conserve token windows by exposing metadata first and loading in-depth instructions and dependent files only upon invocation.
---
[45:14](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=2714s) Session Wrap-Up and Transition
Burke concludes the session by thanking Addy Osmani for demonstrating the workflows codified within his skills repository, joking that he personally attended to receive free training on the codebase. Addy expresses his gratitude for the opportunity to present, and Burke invites audience members to speak directly with Addy off-stage before signing off to prepare for the broadcast's next guest.
## Notable quotes
> [28:25](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=1705s) And I think that at big companies, small companies, anytime that you're working on something that exists and has existing users, you owe it to them to care about quality, to care about not breaking things in ways sometimes agents subtly do. — Addy Osmani
> [33:27](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=2007s) And one of the wonderful things about TDD or having tests or quality gates around is that you can now go and do that code simplification loop and have something that can verify the rest of your logic still works. — Addy Osmani
> [40:08](https://www.youtube.com/watch?v=Q6LR0mXArIQ&t=2408s) You can use a lower cost model often for the planning phase, especially if you're trying to like optimize for tokens, use a lower cost model for the planning phase, use a much more capable model for your implementation. — Addy Osmani
## Video description
In this session, Addy joins us to talk about what agent skills actually are, how they encode senior engineering judgment into workflows any AI agent can follow, and how to use them to get consistent, production-quality results out of your coding tools.
To learn more, please check out these resources:
* https://aka.ms/AgentSkills-AO
𝗦𝗽𝗲𝗮𝗸𝗲𝗿𝘀:
* Addy Osmani
* Burke Holland
𝗦𝗲𝘀𝘀𝗶𝗼𝗻 𝗜𝗻𝗳𝗼𝗿𝗺𝗮𝘁𝗶𝗼𝗻:
This is one of many sessions from the Microsoft Build 2026 event. View even more sessions on-demand and learn about Microsoft Build at https://build.microsoft.com
LIVE150 | English (US)
Broadcast Stage
#MSBuild
Chapters:
0:00 - Intro and Guest Introduction: Addy Osmani returns for a discussion on AI and Google Cloud.
00:05:14 - Structuring Agent Skills: Organizing skills around the software development life cycle (Define, Plan, Build, Verify, Review, Ship).
00:07:15 - Design Pattern for Skills: Overview of how Addy structures each skill with overviews, rationales, red flags, and verification steps.
00:11:03 - Introduction to habit tracker project idea
00:13:03 - Exploring GitHub-inspired analogies and defining MVP success
00:25:25 - Balancing test-driven and review-based workflows
00:34:35 - Security and performance review in vanilla JavaScript
00:35:11 - Emphasis on code simplification and iterative testing with TDD
00:36:01 - Discussion on trust and security in nondeterministic reviews
Addy Osmani argues that software development with AI agents requires disciplined, reusable agent skills anchored directly in the traditional Software Development Life Cycle (SDLC) rather than unguided, ad-hoc prompt engineering. By codifying senior engineering practices, progressive context loading, and deterministic testing into structured files, teams can safely transition from low-stakes prototyping to reliable production engineering.
Agent Skills as Portable, Progressive Dotfiles (0:06)
Osmani describes agent skills as a standardized mechanism for equipping AI models with domain expertise and operational context without permanently bloating the model's active context window. Drawing a parallel to Unix dotfiles and custom shell configurations that developers historically shared to distribute productivity shortcuts, skills encapsulate multi-step engineering workflows that can be adopted or tailored across teams. Unlike transient prompts engineered for single tasks, skills are reusable assets that expose only a name and intent description until an incoming user task demands them, at which point the full instructions are dynamically injected.
Grounding Agent Capabilities in the SDLC (5:14)
To counter the unpredictable output of generative AI, Osmani organizes skills around the standard phases of the SDLC: Define, Plan, Build, Verify, Review, and Ship. Each phase incorporates negative guardrails, activation rules, early warning red flags, and strict exit criteria. During the definition and planning stages, skills guide the agent through structured interviews that convert vague ideas into technical specifications and small, testable tasks with contained blast radiuses. In execution, skills guide test-driven development (TDD), prompting the agent to write a failing test before authoring minimal code to pass it.
Live Execution Verification and Automated Review (28:25)
Osmani contends that while unguided 'vibe coding' may suffice for greenfield experiments without real users, maintaining production software demands rigorous automated quality gates. In the Verify and Review phases, skills trigger local build commands, spin up embedded headless browsers using tools like Playwright or Puppeteer, and test whether rendered interfaces function without throwing runtime errors. Multi-pass review loops then evaluate the codebase for cross-site scripting vulnerabilities, structural coherence, and accessibility, enabling safe code-simplification passes against passing test suites.
Context Economy and Agent Skills Versus MCP (41:38)
Evaluating developer tooling architectures, Osmani and Burke Holland contrast agent skills with the Model Context Protocol (MCP). While MCP serves enterprise needs around granular permissions, live data ingestion, and authentication—such as Microsoft's Work IQ or documentation scrapers like Context7—exposing agents directly to standard Command Line Interfaces (CLIs) via skills often yields faster, lower-friction execution. Holland highlights that skills optimize context budgets through progressive disclosure: rather than packing large MCP tool schemas into baseline prompts upfront, skills only inject detailed instructions and file references when actively invoked by the model.
While structured skills bring consistency and automated test verification to non-deterministic models, Holland and Osmani acknowledge an inherent tension: using text files to tame probabilistic models remains an ongoing experiment, and critical boundaries like security still require deterministic validation before production release.
Source quotes
[28:25] Addy Osmani: And I think that at big companies, small companies, anytime that you're working on something that exists and has existing users, you owe it to them to care about quality, to care about not breaking things in ways sometimes agents subtly do.
[33:27] Addy Osmani: And one of the wonderful things about TDD or having tests or quality gates around is that you can now go and do that code simplification loop and have something that can verify the rest of your logic still works.
[40:08] Addy Osmani: You can use a lower cost model often for the planning phase, especially if you're trying to like optimize for tokens, use a lower cost model for the planning phase, use a much more capable model for your implementation.
Original transcript
[0:06] All right, all right.
[0:07] Am I, Tom?
[0:07] Am I supposed to say we're back?
[0:09] We are back, We're back.
[0:11] All right, folks, As I was saying, director, Google Cloud
[0:16] AI best selling author, Yes.
[0:18] Speaker on AI Developer experience.
[0:21] User experience.
[0:22] Adi Asmani.
[0:24] You're you're very kind.
[0:25] Thank you for being.
[0:26] Hi, folks.
[0:26] Nice to be here so I was I was I
[0:28] told you I was watching a a Bloomberg piece about
[0:31] AI and you were in it and I told my
[0:33] wife I was like I know that guy she's like
[0:35] no you don't I was like I do she didn't
[0:37] believe me she.
[0:38] Didn't believe you?
[0:39] No.
[0:40] It's probably for the best, yeah.
[0:42] But Addie, Addie, I've known you for a long time.
[0:45] You've been writing and making videos and speaking since way
[0:51] back jQuery days.
[0:52] Oh my gosh, doing the.
[0:53] Web, yes.
[0:55] A lot of web performance stuff and now a lot
[0:58] of AI agents and skills.
[1:00] Yes, yes.
[1:02] A lot of agents.
[1:02] And today we talked about you coming out and talking
[1:05] about you have a skills repo which was on the
[1:08] front page of Hacker News multiple times.
[1:10] I try not to look at Hacker News too much
[1:12] these days.
[1:13] You never know if it's going to be good or
[1:14] bad.
[1:15] Well, tell us about it.
[1:17] All right, so today I wanted to talk to you
[1:20] about agent skills.
[1:21] And you know, a lot of people here probably know
[1:23] what they are, but very quickly I'm, I'm Addy, I
[1:26] work on a bunch of agent stuff at Google.
[1:27] So things like the agent development kit, agent platform, and
[1:31] we work on a number of skills related projects at
[1:33] Google.
[1:34] So we've been thinking about skills for a while.
[1:36] If you're not really sure what skills are, they're basically
[1:40] a standardized way to give AI agents new capabilities and
[1:43] expertise.
[1:45] And they've been a really hot topic over the last
[1:47] couple of months, especially as do you remember back in
[1:50] the days when people would like share their secret like
[1:53] shell config and there'd be like a lot of files
[1:56] and they'd be like, hey, this is these are my
[1:58] magic tricks.
[1:59] Yes, my dot files.
[2:00] These are my dot files that work really well for
[2:02] me my.
[2:03] Magic.
[2:03] Tricks.
[2:03] These are my, This is my bag of tricks.
[2:05] And you'd be like, I want that bag of tricks.
[2:08] But then you, you think, well, my, my bag of
[2:10] tricks might be different than your bag of tricks.
[2:12] And so I think of skills in a very similar
[2:14] way.
[2:15] You know, sometimes you want to be inspired by other
[2:17] people's ones.
[2:17] Sometimes it's OK to just take, you know, copy their
[2:20] bag of tricks.
[2:21] And so there, I think there's going to be some
[2:23] stuff in here where people can just copy and take
[2:25] themselves.
[2:25] And sometimes there are going to be things here that
[2:27] will be inspirational.
[2:28] Now, just in case skills are not something you have
[2:32] spent a lot of time on, I thought it'd be
[2:34] interesting to just give people a very quick primer.
[2:38] And so I, I vibe coded this very quick, very
[2:41] silly Windows desktop in a browser.
[2:45] And I thought that I'd drop Clippy in here because
[2:47] I haven't seen Clippy.
[2:49] I haven't seen Clippy so much at build.
[2:51] We're not, we're not allowed to mention Clippy.
[2:53] It's a very.
[2:54] It's a very OK.
[2:55] Yeah, it's very well.
[2:57] There actually is a Clippy suit.
[2:58] There is a wear, but if you wear it, you're
[3:00] not allowed to speak.
[3:01] True story.
[3:02] Really.
[3:02] Yep, those are the rules.
[3:04] You didn't mention it.
[3:04] I did.
[3:05] So, so we're fine.
[3:06] We're totally.
[3:07] Fine broke us into jail.
[3:08] All right, I broke you.
[3:09] This is weird because we have the Mac OS dock
[3:11] down here, but then the windows above it.
[3:12] I like it.
[3:13] It's.
[3:13] Bringing the best of all, it's just this is just
[3:15] terrible.
[3:15] It's like worst of all, the worst of all worlds.
[3:17] OK, so if you're not really sure what skills are,
[3:20] basically there's a standardized way of packaging expertise and and
[3:23] context that you know your agent may not necessarily have.
[3:27] It can package workflows.
[3:28] Your instructions for your agent and you know, the structure
[3:32] of them is kind of this.
[3:34] You have a name, you have a description.
[3:36] There can be a lot more content in here, but
[3:38] basically the name in the description are the main pieces
[3:41] that every single skill files going to have.
[3:44] And these are repeatable.
[3:45] Typically, you're not going to have a skill for something
[3:48] that's one off because a one off thing is going
[3:50] to be more like a prompt.
[3:51] But a skill is something that you or your team
[3:53] might be using on a reusable basis, and it might
[3:56] be useful across a few different projects.
[3:59] Now, skills load on demand.
[4:02] So you know you have a task that arrives into
[4:04] your agent, it will match it with a skill, it
[4:06] will load its steps and then it will try to
[4:08] follow them.
[4:09] It doesn't necessarily need to know more than the name
[4:11] and the description.
[4:14] So agent skills, as you mentioned, this is a project
[4:18] that I created a while back and for some for
[4:21] some back story, I had been taking a little bit
[4:25] slower on open source for a few years.
[4:28] You and I have been doing a lot of open
[4:29] source for a long time, long time, a long time.
[4:32] As you know, you create an open source project, it's
[4:34] a lot like having a kid.
[4:35] You have to maintain it.
[4:38] And so you have to be explicit about when you
[4:40] want to get an open source project out into the
[4:42] world and in a while.
[4:43] So I thought, OK, I will get one of these
[4:44] things out there.
[4:45] I had seen that Gary Tan had, I had put
[4:48] out G stack.
[4:49] That's right, right.
[4:50] And I thought, well, you know, if, if Gary Tan
[4:53] is doing G stack and people are, are learning from
[4:55] it, there's nothing to stop me from putting my perspective
[4:59] on agent skills out into the world.
[5:01] And so I started this project and it got some
[5:03] traction and I thought, you know, it'd be interesting to
[5:06] maybe walk folks through it.
[5:09] My perspective on agent skills is, I would say just
[5:11] a little bit different to other folks.
[5:14] I ground my agent skills around the software development life
[5:18] cycle.
[5:19] I think that they're, you know, I, I lean very
[5:21] heavily into agentic engineering, AI assisted engineering, that side of
[5:26] things where you try to be very disciplined about, you
[5:29] know, I'm going to be explicit about what I want
[5:32] built.
[5:32] I'm going to verify what gets built.
[5:34] I'm going to keep quality in mind.
[5:36] And so for my agent skills, I have a lot
[5:38] of steps that kind of map to the SDLC in
[5:41] here.
[5:41] So define, plan, build, verify, review, and ship.
[5:45] And for each of these different phases of the SDLC,
[5:48] there are a number of different skills that are inside
[5:52] this project, the map in here.
[5:54] So for defining, we've got skills that can interview you
[5:58] to get clarity around an idea if you have a
[6:01] very vague idea.
[6:02] So maybe you've had an idea in the shower and
[6:04] you're like, well, I kind of know what the outcome
[6:06] is, but I actually don't know what the UI is
[6:08] going to look like or I don't know what the
[6:10] details are going to be.
[6:11] You've got a skill here that can help refine it
[6:14] into something more concrete.
[6:15] You can do spec driven development.
[6:17] We've got planning skills for turning things into tasks.
[6:20] We've got building skills that can help you sort of
[6:23] refine this to a place where you've got very good
[6:25] front end UI, your API and interface design is in
[6:28] a good place, and this sort of skills for a
[6:31] number of these other phases for verification.
[6:33] That's really important.
[6:35] You know, I think you and I have done a
[6:37] lot in the browser over time, right?
[6:38] I still build, I, I used to work on Chrome.
[6:40] I still build a lot of, you know, projects that
[6:42] will render in the browser.
[6:44] And so testing in the browser automatically with an agent
[6:47] these days is something that I care about.
[6:49] So I have a skill that will do that.
[6:51] Automatic debugging is also part of this workflow.
[6:54] I've got a code review loop in here too that
[6:56] includes things like code simplification, security, and then I've got
[7:00] ship skills as well that will help you with everything
[7:04] from your CI to your Git workflow, your documentation, shipping,
[7:07] and launch.
[7:09] Now, there are a lot of phases in here.
[7:10] I'm actually going to show you how these work, but
[7:12] there's basically a pattern that I use for all of
[7:15] my skills.
[7:15] There's an overview I capture, like when these things should
[7:19] be used.
[7:20] I have rationalizations like why should this be used and
[7:24] why should this not be used?
[7:25] So the agent has a little bit of a guardrail
[7:28] that it can, it can keep in mind and then
[7:30] red flags as well so that the agent knows if
[7:33] things are really going kind of off kilter and then
[7:35] verification.
[7:36] So how do we know that we actually did the
[7:38] steps right and in a good job?
[7:40] Now all that stuff just maps to commands as well.
[7:42] So you can explicitly just use like a slash command
[7:46] in copilot in any of your agentic coding tools and
[7:49] trigger any of these phases.
[7:51] Now you don't have to use, of course, my agent
[7:53] skills, as I was saying, they're a lot like your
[7:55] bag of magic tricks or dot files.
[7:57] If there's something in here that's useful to you, copy
[8:00] it, steal it, you know, help, you know, have it
[8:02] make you productive.
[8:03] If you find that the way that I do things
[8:05] is helpful, you know, you can go in and use
[8:07] it wholesale.
[8:08] But I want to just show you a little bit
[8:10] of this in action.
[8:11] So I've got a scaffolded out project here where I've
[8:15] installed the skills.
[8:16] We've got some agent files, we've got prompts or just
[8:20] mapping all of those skills.
[8:21] This is what happens when you just install it inside
[8:23] a project.
[8:24] And then we've got some of the skills themselves, and
[8:28] I'm over here inside sort of the Copilot sidebar.
[8:31] I've selected Gemini 3.5 Flash.
[8:34] I work at Google, I work on Gemini, so I'm
[8:36] going to be using Gemini 3.5 Flash here.
[8:38] It's a great model for agentic coding and for agent
[8:41] tasks.
[8:43] I believe that, you know, VS Code has also got
[8:45] like an agent's view these days as well, right?
[8:48] So all of these commands, you know, you can just
[8:50] type in slash, you will see that there are additional
[8:53] commands populated here for using the agent skills and you
[8:56] can use any of these.
[8:57] So like things like refine things like the code simplification,
[9:00] etcetera.
[9:01] But just so that we can see what's actually getting
[9:04] built out, I'm going to stick with using this view.
[9:08] And we can start off with maybe just even doing
[9:12] a quick look at our skills.
[9:15] And I'm just going to show you test development.
[9:17] I was talking about, you know, maybe giving you a
[9:20] bit of an insight into what these files contain.
[9:23] Now, you'll see a lot of content in here.
[9:26] I try to be very diligent about what ends up
[9:29] in context windows.
[9:30] So again, if you feel that there is too much
[9:33] that is in here for your needs, you can always
[9:36] trim it back.
[9:36] You can always optimize it further.
[9:38] But I try to be very explicit.
[9:40] So for test driven Development, I capture the DDD cycle.
[9:44] I have a very explicit take on like what does
[9:46] it mean to have a failing test?
[9:47] What does it mean to have a passing test?
[9:49] How should you think about refactoring?
[9:51] What are other patterns that I personally think work really
[9:54] well?
[9:55] Many of these patterns were ones that have been inspired
[9:58] by how we build software at scale at Google.
[10:00] And so I thought they'd be interesting to kind of
[10:03] encode inside these skills.
[10:04] So you'll see things like the test pyramid in here,
[10:07] decision guides.
[10:09] There's a number of best practices that are encoded in
[10:11] here as well.
[10:12] Lower down you'll also see that I capture things like
[10:15] test anti patterns, things to explicitly avoid, how to approach
[10:19] browser testing.
[10:21] So this is that connective tissue that can then take
[10:23] us back to things like browser testing, browser debugging.
[10:28] I tell it what to check.
[10:29] I tell it how to think about security boundaries where
[10:32] testing is concerned.
[10:34] You can be as explicit or open-ended as you kind
[10:37] of want with these things.
[10:38] I try to be explicit just because I think that
[10:41] there's value to being intentional with how you approach these
[10:44] things.
[10:45] Now, what I thought would be interesting, I've been someone
[10:48] that for a lot of my life has been trying
[10:50] to optimize my productivity.
[10:52] I think I've probably failed at it a lot.
[10:56] And so habit tracking is something that I look at
[10:58] now and then, right?
[10:59] I think a lot of people try to improve their
[11:01] habits and their systems.
[11:03] So I thought it'd be interesting for us to try
[11:05] building out a habit tracker.
[11:07] And maybe, you know, if you take a look at
[11:09] everybody's kind of looked at their GitHub contributions graph, maybe
[11:13] we have a habit tracker that uses that kind of
[11:15] visual.
[11:16] So like how, how well are you doing and following
[11:19] your habits over time?
[11:20] So, so we're going to kind of start off with
[11:23] here is I'm just going to trigger the refine command.
[11:27] And the reason I'm going to do this is I
[11:29] have a raw idea.
[11:30] So I want to build out a habit tracker, right?
[11:34] So we're going to say just something like a habit
[11:40] tracker GitHub inspired.
[11:43] And I don't really want a database back end.
[11:47] Maybe let's just have it all work in the browser,
[11:51] so store everything in the browser?
[11:54] That's relatively vague.
[11:55] It's pretty vague, pretty high level.
[11:57] Are you going to say contribution graph or are you
[11:58] going to leave that out?
[11:59] I'm just going.
[11:59] To keep it, I'm just going to keep it GitHub
[12:01] inspired.
[12:01] I could say contribution graph, but that's being explicit.
[12:04] That is right.
[12:05] So we're just going to go and trigger refine now.
[12:08] And so it's analyzing our prompt parameters, it's analyzing the
[12:12] core components of the request.
[12:14] It's triggering the skill.
[12:15] You can see that it's been reading that skill in
[12:17] place.
[12:18] Now the first thing that's popped up here is it's
[12:20] asking me clarifying questions.
[12:22] So who is the primary target user?
[12:24] Great question.
[12:25] It doesn't know if this is just for me or
[12:27] I'm building this for a team, or I'm building this
[12:29] for my family or my friends or what.
[12:31] So the audience is going to be, let's say a,
[12:34] a room of software engineers at Build right or YouTube,
[12:38] because people are going to be watching this later.
[12:43] Just anyone.
[12:44] Just anybody, what are the constraints and expectations for browser
[12:47] only storage?
[12:48] Great question.
[12:49] You could be using index DB, local storage, session storage,
[12:52] lots of different options.
[12:54] I'm going to keep it very simple.
[12:55] I'm OK with local storage for this beyond the standard
[12:58] contribution grid, so here it was able to figure that
[13:02] out itself.
[13:03] What GitHub analogies do you want to explore?
[13:05] Like committing a habit, branching variations, pull requests?
[13:09] I don't want to go too deep into these analogies,
[13:12] so I think let's keep it.
[13:13] Let's keep it simple with the contribution grid.
[13:17] Interesting that it's leaning into that.
[13:19] It's like it wants to make the whole thing about
[13:21] GitHub.
[13:21] And this is one of those things, if you take
[13:24] a look at how that skill is defined, it actually
[13:27] has language around trying to begin converging on the direction,
[13:30] the idea that you have leaning into like, OK, well,
[13:33] I kind of get what you're going for.
[13:35] Let's keep going down that path.
[13:37] So what does success look like for the MVP?
[13:40] Because very often if you define like just a high,
[13:42] a high level prompt, it doesn't know if you're trying
[13:45] to build out something for a start up or a
[13:47] side project at the weekend or what.
[13:49] So I feel like the performance requirements are good.
[13:54] Like all of this stuff seems good.
[13:55] I don't necessarily need it to be offline first with
[13:58] service workers just yet.
[13:59] So load fast, clean UI, that's about it.
[14:07] Load fast and have a clean UI be responsive.
[14:14] OK, so we've got all these answers now.
[14:16] Didn't take us very long just to start getting clarity
[14:19] around this, right?
[14:20] I didn't have to go writing a big spec myself
[14:22] or anything like that just yet.
[14:24] And so it's trying to read the rest of my
[14:26] project yet just now trying to see if there's any
[14:29] other context in there.
[14:31] This is a fresh project, so there's not a whole
[14:32] lot that it needs.
[14:33] And here's the output, right?
[14:35] It has a problem statement.
[14:37] It has statements around like how we differentiate directions, think
[14:40] about stress tests, and it gives us a few directions
[14:43] we can take.
[14:44] So direction A is a deaf, deaf profile Configurator.
[14:47] So a very minimalist high fidelity clone of a GitHub
[14:50] profile allows us to track habits the same way that
[14:53] you would GitHub repositories.
[14:55] There's a lot more detail in here.
[14:57] Direction B is more of a keyboard driven habit terminal.
[15:01] I'm more of a 2DS.
[15:02] Are so hot.
[15:04] Right now, yeah, 2DS are so hot.
[15:06] Direction C is a markdown SVG exporter, so a plain
[15:09] text back end tool, your habit configuration and grid data.
[15:13] So this is more data.
[15:15] This is more like you really want to enter in
[15:17] raw data and manage that, which is not really the
[15:20] vibe I was going for.
[15:21] I think that the first one's probably the closest to
[15:24] what I had in mind.
[15:26] So I'm going to go with direction A.
[15:29] And you can also see that it's got other assumptions
[15:31] in here and push backs.
[15:33] So it's asking me which direction resonates the most.
[15:35] I'm just going to say direction.
[15:36] A.
[15:37] Did it recommend one I couldn't see under the counter?
[15:39] There so we can scroll back.
[15:40] Once you pick AB or CI will produce 1.
[15:43] It didn't recommend 1.
[15:44] You can actually change your skill files to say, well,
[15:47] I want you to provide your own perspective on it.
[15:51] In this case, I'm trying to you know.
[15:53] Because I notice models like to recommend and they almost
[15:55] always when they give you choice and be like, well,
[15:58] this is what I do, Yeah.
[15:59] And then I'm like, well, if that's what you do,
[16:01] then that's what I want to do.
[16:02] Well and sometimes I will ask the model like give
[16:05] me 3 choices and tell me what you think I
[16:07] should do just in case.
[16:08] Yes.
[16:09] But then I feel like I'm not.
[16:10] I'm just always doing what the model wants, you know
[16:12] what I mean?
[16:13] I'm like, well if you think it's best and it's
[16:14] probably best, which is not true, I have.
[16:16] So much to say about cognitive debt and cognitive surrender.
[16:19] That's right, that your next article on.
[16:23] So what we have here, so the app is called
[16:25] Streak, we have a problem statement, we've got a direction
[16:28] here.
[16:29] We've got some assumptions to validate like what is the
[16:32] retention rate?
[16:34] What is like the frequency going to be around habits?
[16:37] What's the mobile usability going to be since engineer configure
[16:40] setups on desktops, but often complete habits on mobile.
[16:43] Is local storage enough?
[16:45] Well, probably at local storage is well supported everywhere at
[16:47] this point.
[16:48] So I think that pretty much all of these ideas
[16:50] are cool.
[16:51] So we have our MVP scope defined for us here
[16:54] and it also says what it's not doing.
[16:57] So it's not doing cloud sync, it's not going to
[17:00] be doing advanced social features.
[17:02] And it's got some open questions for us if we
[17:04] want to provide clarity around that.
[17:06] And it also asks us, do we want to just
[17:07] save it?
[17:07] So I'm going to say yes, save it.
[17:11] So we've now taken a very high level idea and
[17:13] we've refined it.
[17:15] Now the next phase of this is actually turning this
[17:18] high level idea.
[17:19] So we've gotten it into a better place.
[17:21] Let's turn this into a more detailed spec.
[17:24] Now for some folks, you might say, well, it feels
[17:26] like it's a few, it's a few steps.
[17:27] You don't have to follow my way of doing things.
[17:29] If you want to just have like one step for
[17:32] creating your spec, you can do that.
[17:35] I just happen to like specificity.
[17:36] So you like to plan.
[17:38] You want the plan, the spec, and then the implementation.
[17:42] I'm a plan implement guy myself.
[17:43] Just skip over.
[17:45] That's totally OK Everybody's got their own workflow.
[17:47] Here you can see the file that it's generated, and
[17:50] this is going to be a starting point entry for
[17:52] the next step.
[17:53] So the next step is going to be spec.
[17:56] So we've got our idea.
[17:58] We can go and just type in slash spec and
[18:00] it's then going to read in the output from that
[18:03] last phase, it's going to start being able to generate
[18:06] something that's much more concrete.
[18:08] So it's taking in those assumptions, it's defining success criteria,
[18:12] scaffolding out the tech stack a lot more in detail
[18:15] and then it's got those open questions in a little
[18:18] bit more detail that.
[18:19] Is really snappy.
[18:20] Yeah, it's pretty quick.
[18:22] Again, use Gemini 3.5 flash or whatever model is out
[18:25] at the time you're watching this on YouTube.
[18:28] Yeah, 'cause it move.
[18:30] AI moves fast.
[18:31] 4 hours everything will be.
[18:32] Different.
[18:32] Everything will be different, so we've got some open questions.
[18:36] Grid generation techniques.
[18:37] Should we use a standard GitHub contribution?
[18:39] Grids.
[18:41] We prefer rendering grids as modular dynamic SVG group structure
[18:45] or CSS grid element layouts.
[18:48] I'm going to be out.
[18:49] I know CSS grid, I use SVG, but I'm not
[18:51] an expert so I'm just going to for one.
[18:54] I'm going to say choose what you think is best
[18:58] and then first visit boilerplate.
[19:01] What default habits should we set up for new visitors?
[19:05] That's a good question.
[19:09] Are we bad habits or are we tracking bad?
[19:11] Habits.
[19:11] We're we're tracking good habits.
[19:13] OK, good habits we should good habits.
[19:15] Exercise, hydration, reading.
[19:20] Reading meditation.
[19:22] Do people meditate?
[19:22] Scrolling?
[19:23] Do scrolling?
[19:23] Do scrolling OK.
[19:25] Meditation.
[19:26] Meditation, probably.
[19:27] Better than do meditation after you're do scrolling.
[19:30] OK, do you have a desired location for this file?
[19:33] I'm just going to let it do what you think
[19:36] is best.
[19:39] Cool.
[19:40] What I love about this is all of this UI.
[19:43] All these questions are directly inside of the copilot sidebar.
[19:46] I don't have to use some other app for it.
[19:49] Whatever you're a gentic UI surface is, you can just
[19:51] have a similar experience there.
[19:53] So it's now created a spec for us.
[19:54] I'm going to keep this and the next phase you
[19:57] can go and you can take a look at the
[19:58] spec.
[19:59] By the way, it's over here.
[20:00] It's going to be a much more detailed version of
[20:02] that original file that we had.
[20:04] But you'll see that we have success criteria.
[20:07] We've got metrics in place here for performance, so things
[20:09] like largest content, full paint.
[20:12] We've got a tech stack that's defined.
[20:14] This is going to be very simplistic.
[20:15] So vanilla JavaScript.
[20:17] I didn't say I wanted something in React.
[20:19] I'm OK.
[20:19] With it never asked you about the tech stack, did
[20:21] it?
[20:21] Yeah.
[20:22] It didn't ask me about the tech stack, and that's
[20:24] another thing that you can encode inside of your skills.
[20:26] So this is an assumption that you just let.
[20:27] This is an assumption that I'm OK with.
[20:30] You can assume like it's defined bytest and playwright for
[20:34] our end to end testing, which I'm OK with our
[20:36] storage, and then project structure and code style.
[20:39] And if there's anything in here that you don't like,
[20:42] you can always go back and either manually tweak it
[20:44] or work with your agent.
[20:45] So you configure this more.
[20:47] So you've got your spec.
[20:48] Now the next thing that you might want to do
[20:50] is actually start breaking this down into individual pieces.
[20:53] Now, this is useful if you've got a large project
[20:56] that you're working on.
[20:57] If you're working on something small, you probably just want
[21:00] to go straight into implementation.
[21:01] I'm going to show you this plan in action anyway.
[21:04] So we've got a plan step here.
[21:07] And what we can do with plan is I can
[21:10] go and I can run plan.
[21:11] I'm just going to show you this working.
[21:13] And what this can do is help breakdown.
[21:16] What we say in software engineering often is if you've
[21:18] got a big problem, break it down into smaller pieces,
[21:21] right?
[21:21] And plan kind of helps you with that.
[21:23] It breaks your big spec down into granular chunks that
[21:26] can then be implemented.
[21:28] And that's really good if you're working with TDD because
[21:31] you've got, you know, very individual pieces that can be
[21:34] tested, verified as you move on to other pieces.
[21:36] People have lots of different ways that they like doing
[21:38] TDD.
[21:38] So I'm not going to assume that my way is
[21:40] is the right way or anything like that.
[21:42] So it's going and it's scaffolding out the basic parts
[21:44] of the project right now because that's fine.
[21:47] Like it can set up our boilerplate before we actually
[21:49] go and start implementing the rest.
[21:51] I'm just going to do keep on that and you'll
[21:54] see that it's asking before beginning phase one, I should
[21:57] initialize our structured To Do List to provide full transparency
[22:00] and it's going to do that now.
[22:02] So what you're going to have here is the package
[22:06] dot Jason file, which we see has been created.
[22:10] The implementation plan is established and saved to plan.
[22:13] So we've got a task list.
[22:15] Here you see phases and tasks.
[22:18] So we've got phase one task one, which has its
[22:21] acceptance criteria.
[22:22] And this is like build the pure logic, TypeScript interfaces,
[22:25] your types, your functions to compute the streaks, your total
[22:29] contributions within the last like 365 days, the local storage
[22:32] pieces, basically stuff that doesn't necessarily touch your UI.
[22:36] And we've got some acceptance criteria here as well.
[22:38] So we've got a list of things that have to
[22:40] be true as well as verification.
[22:42] So the test suite has to be able to run
[22:44] on that piece of logic in order to move forward.
[22:48] It also suggests, like, what files are probably going to
[22:51] be touched as a part of this just to like
[22:53] really harm them down.
[22:54] If you've been doing any vibe coding or genetic engineering
[22:57] for a while, you know that one of the ways
[22:59] in which we try to limit our blast radius is
[23:01] by saying, well, I'm just going to target these specific
[23:04] files because especially if you're working on an existing project,
[23:07] you don't want it to start overwriting or touching files
[23:10] that maybe have nothing to do with the task at
[23:12] hand, right?
[23:14] So we have a few different phases and tasks here.
[23:16] Some of the other phases will include our data storage.
[23:19] So that layer for local storage, it'll include sort of
[23:23] the visualization of our habits as that GitHub style contribution
[23:27] graph as well as the rest of our UI.
[23:30] So we've got our plan here.
[23:31] What you can do, again, this supports being very granular
[23:34] or or not having to think about that in as
[23:37] much detail.
[23:37] So if I wanted, I could do something like slash
[23:40] build task one and just have it do the first
[23:43] task on that list.
[23:44] So let's see what it does.
[23:45] It's created for to do's as a part of that.
[23:49] It's evaluating it.
[23:50] It's reading our test driven development skill right now.
[23:53] You can see that it's installing those first things.
[23:55] I'm also just going to do.
[23:56] Yeah, if you always allow.
[23:58] You can do it down at the very bottom and
[24:00] turn on bypass approvals if you want to.
[24:03] I'm learning something new.
[24:04] Where do I where?
[24:05] Oh wait, wait, wait.
[24:05] I see what you're talking about here.
[24:06] Right there, yeah.
[24:07] And then we'll stop asking, are you a bypass approvals,
[24:10] you recommend bypassing approvals?
[24:12] I bypass approvals on all my personal projects.
[24:19] So now you're building one phase at a time.
[24:23] Is this generally how you work or are you more
[24:25] I think?
[24:26] It really depends on what you're building.
[24:28] So if I am building a personal side project and
[24:31] I just want to build something like maybe it has
[24:34] one purpose, probably going to skip building out one phase
[24:37] at a time this way and just have it build
[24:40] the entire thing.
[24:41] If I'm building something relatively complex, I'm OK doing it
[24:45] a phase at a time.
[24:46] It might feel like it's slower, but the fact that
[24:48] you go through all of these steps and you know,
[24:51] well, this slice is tested as we build out the
[24:54] UII know nothing else is broken.
[24:56] I've now done our data layer.
[24:58] Nothing else is broken.
[24:59] This gives you a lot more confidence as you're working
[25:01] through.
[25:01] It's just a just a different way of approaching.
[25:04] It's such a trade off though because then you know
[25:06] the back in the loop, like once again, you're the
[25:09] problem.
[25:09] You're slowing the agent down.
[25:11] It's tough.
[25:12] I struggle with this myself.
[25:13] Yes, yes, absolutely.
[25:15] And I would say that, you know, you have to
[25:17] make a judgement call at the end of the day
[25:19] about how much time you want to invest in where
[25:22] in in the software development life cycle you want to
[25:24] invest it.
[25:25] Do you want to put a lot of time into
[25:28] your spec?
[25:29] Just have your agent build out a lot of code
[25:32] and then spend time reviewing it, defining your tests at
[25:36] that point figuring out like, how do I evaluate quality
[25:40] like that?
[25:40] That can be OK as well.
[25:42] Or do you want to approach it with TDD in
[25:45] mind?
[25:45] Do you want to have like an explicit strategy around
[25:47] how you're going to verify quality so that as you're
[25:50] going through, it's already addressing these things?
[25:52] And I don't think there's a right or wrong way.
[25:54] It's just different ways of working, you know what I
[25:56] mean?
[25:58] So what you can see with this first phase is
[26:00] that the implementation is test driven.
[26:02] We have our first target failing red test to to
[26:05] tell us that OK, we have a test, it's failing,
[26:08] We're going to implement the minimal clean logic in streaks.
[26:12] We're red green here, yes.
[26:14] And as I said, you don't have to do this
[26:16] with like individual tasks.
[26:18] We can just keep running, built to work through the
[26:21] rest of this and then we can get on to
[26:23] other phases.
[26:24] So you can see that it is thanks to to
[26:27] Burke's tip around bypassing approvals.
[26:30] We're just going to keep running through this.
[26:32] And I'm a person that people will often talk about,
[26:35] you know, how do you as an engineer understand what
[26:38] is getting generated if you're not reading all of the
[26:41] code?
[26:42] Yeah, very often as as your agent is generating stuff,
[26:45] what are you doing?
[26:47] Are you switching over to another agentic task?
[26:50] Like very often I guess I found myself doing that.
[26:52] And so I started to slow down a little bit.
[26:55] And these days I try to read the trajectory a
[26:57] little bit more like what did it say?
[26:59] What was it thinking?
[27:00] Why was it thinking what it was thinking?
[27:03] And is there any nugget of information in there that
[27:05] I can extract that just lets me know?
[27:07] Oh, OK.
[27:08] Well, that was the way I I was expecting.
[27:11] That's what you mean.
[27:11] You know what I mean?
[27:12] Yeah, so it's interesting because I, I don't know what
[27:15] everybody else does, but I, I watch the agent work.
[27:19] Now, I'm not reading everything that it's doing.
[27:21] I'm mostly just staring at it when I should be
[27:24] doing something else.
[27:25] But I'm just, I'm literally watching agents spin.
[27:28] But I'm curious like, are you like, are you looking
[27:31] at the code?
[27:33] Great question.
[27:34] So I try to, I generally, unless it's a personal
[27:37] project, there's a lot of personal projects end up being
[27:41] throwaway things.
[27:42] Oh, I have this, I have this need for an
[27:44] hour.
[27:45] I'm just going to build something that's thrown away.
[27:47] And in those situations, I'm very OK with saying if
[27:50] I don't understand the code, the agent is going to
[27:53] go fix something for me.
[27:55] However, if it's going to be something I'm going to
[27:57] maintain for at least a few weeks or a few
[27:59] months, I generally go back and at least understand the
[28:02] architecture.
[28:03] And I try to read through some of the core
[28:06] files so that if I discover that the agent wasn't
[28:08] able to fix something or it goes off on a
[28:11] tangent, I am able to go back in and make
[28:13] fixes myself.
[28:14] You know, very often.
[28:16] So I'm going to keep working through build and we
[28:19] can keep chatting.
[28:20] So it's going to keep doing it's TDD phases.
[28:23] As each slice gets implemented, it's going to go from
[28:25] red to green, implement the phase and get everything done.
[28:28] This is so interesting.
[28:29] I didn't even know about Red Green testing until Spec
[28:32] Kit came out.
[28:33] It was my first.
[28:34] It was the first time I'd ever seen that.
[28:36] That's the idea of writing failing tests and then making
[28:39] them work, and it was like 45 years old.
[28:42] It's kind of sad.
[28:44] You do not what it is.
[28:45] You do not look over 45 at all.
[28:47] I'm not, yeah.
[28:49] 445 was yesterday.
[28:51] Happy birthday.
[28:52] Thank you so much.
[28:54] So we're going to keep doing this.
[28:56] I also wanted to to have to share a comment
[28:58] on this.
[28:58] I think that very often in the entire sort of
[29:02] agentic engineering diaspora, the industry paints very broad strokes about
[29:07] best practices.
[29:08] Like if you're, if you're on Twitter, if you're on
[29:12] any social network, very often the best practices for a
[29:15] solo founder or a small startup team will be shared.
[29:19] And the best practices for that kind of team that
[29:22] maybe don't have users yet, maybe they're working on an
[29:25] Evergreen code base.
[29:27] Those are very different to people who are working on
[29:30] something, either a legacy brownfield with a team.
[29:34] And so I think that it's important just to understand
[29:37] that, you know, there are situations where it's OK to
[29:39] just give in the vibes and have the agent figure
[29:42] things out.
[29:42] And if something goes wrong, we'll just have the agent
[29:44] fix it.
[29:45] In other situations where actually understanding what's happening behind the
[29:48] scenes is still quite important.
[29:49] Yeah, 100% agreeing.
[29:50] I actually so what's super interesting about this is that
[29:53] I think myself and most people are looking for what
[29:56] it just tell me what to install that's going to
[29:59] make everything work right.
[30:00] Is it is it agent skills?
[30:02] Is it super powers?
[30:03] Is it G stack?
[30:04] Like what is it?
[30:05] And the answer is it might be some of any
[30:08] of those things, but your job is less about writing
[30:11] code now and more about building these work flows that
[30:14] actually work.
[30:15] And it's not always the same, even for different projects
[30:19] within the same organization.
[30:21] So absolutely, it's a, it's a very, I don't know
[30:24] what to call it.
[30:25] It's not software engineering.
[30:26] It's it's not automation.
[30:29] It's, how would you even describe this?
[30:32] Like we all work at McKenzie now.
[30:35] I I don't know.
[30:35] I, I, I acknowledge that agentic engineering we're, we're, we're
[30:40] now working on a spectrum, right?
[30:42] And there are going to be times when we're vibe
[30:43] coding, there's going to be times when we're agentic engineering.
[30:46] And the more diligence you have to apply to the
[30:48] process, the closer you are getting to agentic engineering.
[30:52] And I think that at big companies, small companies, anytime
[30:55] that you're working on something that exists and has existing
[30:59] users, you owe it to them to care about quality,
[31:02] to care about not breaking things in ways sometimes agents
[31:05] subtly do.
[31:06] Yeah, 100% agree.
[31:07] If you're building a a habit tracker, that's one thing.
[31:10] If you're shipping VS Code, you have to be pretty
[31:13] meticulous, Yeah, about not breaking that.
[31:16] Yeah.
[31:16] So we have about 10 minutes left here, so.
[31:20] What I'm going to do is I'm just going to
[31:21] skip ahead a little bit and just show you very
[31:24] quickly some of these other phases.
[31:25] So the agent skills package also includes a verify step.
[31:31] Now what Verify does is it's able to just check
[31:34] that the implementation as it has been done so far,
[31:37] whether it's complete or whether we've partially implemented something that
[31:41] can actually be used just yet, can run in a
[31:44] browser and actually do what it needs to do.
[31:47] So it's going to go and check that it's actually
[31:49] able to spin something up.
[31:51] But let's see if enough of it has been built
[31:53] that it's able to do that.
[31:55] So it's doing it's MPM run build right now.
[31:57] It's going to spin up it's MPM run dev and
[31:59] we'll see if this actually works.
[32:00] So we have.
[32:01] We have something that looks like a GitHub profile where.
[32:04] Here, pull that picture from.
[32:05] I have no idea who is that the magic of
[32:08] LLM.
[32:10] That someone if that person's watching.
[32:12] Someone.
[32:12] Someone in the world.
[32:15] Hello whoever this is this could this could be like
[32:19] a non developer as well.
[32:20] This could be a person that just likes to like
[32:22] bake cookies somewhere in the world.
[32:23] It just happens.
[32:24] To be on GitHub.
[32:25] Yeah, it just happens to be on GitHub.
[32:27] But you know, it's it's opened up this browser directly
[32:30] inside of VS Code.
[32:32] It's able to run its checks behind the scenes to
[32:35] see OK, well, is anything actually broken?
[32:37] If I interact with UI, does anything actually begin to
[32:40] break?
[32:41] And I think that this is very interesting, like if
[32:44] you actually go to the prompts and you go to
[32:46] our verify skill, it will end up trying out the
[32:49] browser testing with dev tool skill.
[32:51] There are many ways to do sort of automated browser
[32:54] testing these days, whether you're using Puppeteer, Playwright, the Versal
[32:59] like agent browser, there's a lot of different options.
[33:02] I'm not going to say there's there's a right one,
[33:04] but choose what makes sense to you.
[33:06] I just think there's a lot of really great tools
[33:09] these days for just making sure that your thing basically
[33:11] works.
[33:12] Whether you decide to kind of encode all of your
[33:14] user journeys and test them out very, very holistically is
[33:17] kind of up to you at the end of the
[33:19] day.
[33:20] Web devs as usual, have it better than anybody else.
[33:23] Right?
[33:24] Like it's so much harder to do with native apps.
[33:27] Now for for my skills, the review phase ends up
[33:30] being really important and people have a lot of opinions
[33:34] about review.
[33:36] I tend to find, and this is something that I
[33:38] found talking to engineers at Google as well, we still
[33:41] have a culture where we tend to have engineers manually
[33:45] review code.
[33:46] Even even with that, even with trying to bring AI
[33:49] into our code review process, having, you know, an agent
[33:53] do a local first pass or multi pass is really,
[33:56] really valuable.
[33:58] Now there are some people that will take this all
[34:00] the way to adversarial code review with very deep, you
[34:03] know, patterns.
[34:04] There are people who will have other models, you know,
[34:08] like, hey, I'm going to, I'm maybe I'm going to
[34:11] use Gemini for the implementation and Opus or codecs rather.
[34:15] So you have a lot of flexibility here.
[34:17] There is, again, no right or wrong way.
[34:19] People will often decide these things based on vibes.
[34:22] But what you'll see is we have a number of
[34:25] different kinds of review checks that were done here.
[34:27] So what's working well, what's technically considered correctness?
[34:31] So all of the unit tests that were implemented so
[34:33] far appear to be, you know, passing.
[34:35] We have no security issues.
[34:38] It seems, you know, we're working with vanilla JavaScript.
[34:42] We of course want to avoid XSS issues or cross
[34:44] site, you know, cross site scripting, anything like that.
[34:48] Readability in architecture seems to be in a good place.
[34:50] Performance seems to be in a good place.
[34:51] This is a simple, you know, application and it also
[34:54] applies some recommendations.
[34:56] So keyboard navigations for that contribution graph makes sense, right?
[35:00] Like, that's not something that I had considered.
[35:03] And you might find that depending on the complexity of
[35:06] what you're working on, that you, you can have this
[35:08] be much more elaborate.
[35:11] Another part of code review that I find useful these
[35:14] days is code simplification.
[35:16] And very often what we'll do is we'll have an
[35:18] agent implement something.
[35:19] We'll verify, maybe you'll read the code, maybe you'll verify
[35:22] that, hey, it at least runs in the browser.
[35:24] Or, you know, if you're building a native app, hey,
[35:26] it at least runs, but you don't necessarily go back
[35:29] and ask yourself, hey, could this actually be simpler?
[35:32] And one of the wonderful things about TDD or having
[35:35] tests or quality gates around is that you can now
[35:38] go and do that code simplification loop and have something
[35:41] that can verify the rest of your logic still works.
[35:44] Yeah.
[35:45] Right, very interesting.
[35:46] So I questioned on the security one, how much do
[35:50] you trust the non deterministic?
[35:52] Because to me, this is the, this is the, this
[35:54] is where the, the rubber meets the road, right?
[35:57] The rest of this stuff you can deal with.
[35:59] The security stuff cannot.
[36:01] How much do you trust that review that you're not
[36:04] pushing a key, you're not pushing some sequel injections, something
[36:07] that's just going to get you in a ton of
[36:09] trouble down the?
[36:10] Road Oh yeah, I think that there are a lot
[36:13] of goods open source and commercial offerings that go even
[36:17] deeper into security than than these skills do.
[36:20] And so there are a lot of things that like
[36:22] we've seen anybody that's been doing by coding and Jenning
[36:25] engineering for a while has run into these issues, right?
[36:28] Very often people will be using API keys in horrendous
[36:32] ways, right?
[36:33] They will be quickly putting together something and not realize
[36:36] that oh hey wait, there are actually tons of data
[36:39] leakage issues or the way that Office implemented is leaving
[36:42] you exposed to all kinds of problems.
[36:43] Or somebody can just nail your API over and over
[36:45] again because it's not locked down.
[36:47] Exactly.
[36:48] And if you're, if you're a senior engineer, if you're
[36:50] experienced, you know what to look out for.
[36:53] If you're intermediate, if you're not quite as technical, if
[36:56] you're coming at this without as much of that background,
[36:58] or maybe you are an experienced engineer and you're just
[37:01] lazy.
[37:02] Because sometimes we are lazy.
[37:04] It's useful to encode those things in skills just as
[37:07] like a sanity check for yourself.
[37:09] Oh, actually List specifically.
[37:11] Yeah.
[37:11] So I find that I cannot think of all the
[37:13] edge cases, but models are actually really, really good at
[37:17] this.
[37:17] Like if you if you ever ask a model to
[37:20] review a code base, it will almost always find something
[37:23] that you need to change your input, right.
[37:26] They're really, really meticulous and good at that.
[37:29] So yeah, again, I don't know, I I feel like
[37:31] we need maybe better products or whatever it is, but
[37:34] all of this to me agents code should go through
[37:37] some deterministic gate That's like, yes, security sign off has
[37:40] been achieved because I don't trust I'm scared to death
[37:43] to push anything live on Twitter and be like, here's
[37:46] what I built and then have somebody be like, oh,
[37:49] and here's your gym.
[37:50] I key.
[37:50] And I think that's that's where there is a lot
[37:53] of value in understanding what does good mean?
[37:56] What does done mean?
[37:58] Right.
[37:59] And if you care about security, you care about quality,
[38:01] you care about performance, you care about accessibility, you care
[38:05] about any of these things, that's a good reminder to
[38:07] try and coding those into how you approach quality gates
[38:10] in your projects.
[38:11] Yeah, skills are just one way of of encoding that
[38:13] into how you think about all this stuff.
[38:15] But I think that just having tooling in place to
[38:18] make sure that you're not merging in code that's going
[38:20] against those best practices is always is always a good
[38:23] idea.
[38:23] Yeah, I feel like we need more of these deterministic
[38:25] gates.
[38:26] I just don't know what they are like right now.
[38:28] Markdown is the solution to everything.
[38:30] It's like, well, we have nondeterminism.
[38:32] How are we going to fix that with more nondeterminism
[38:36] with text files, With text files.
[38:38] So we're at about 6 minutes here.
[38:40] I'd like to do some Q&A because you can continue.
[38:43] Yeah, yeah.
[38:44] So I'll wrap this up in a minute.
[38:45] So there are a lot of great teams, labs who've
[38:48] been thinking about code simplification.
[38:51] And very often what I love to do is anytime
[38:53] that they open source their work or they write up
[38:55] a blog post about their work, I go and study.
[38:58] Like, is there something that I can learn from what
[39:00] they're doing that I can then incorporate into my skills
[39:02] or how I work?
[39:04] You can do that for code simplification as well.
[39:06] Even for this simple app, it's already found like 3
[39:09] or 4 opportunities to simplify the code.
[39:11] So that's great.
[39:12] We've got a ship step in here as well.
[39:14] Just for time.
[39:15] I'm just going to skip ahead and show you like
[39:18] one that I built earlier.
[39:20] This is like this is called streak.
[39:22] It's got a GitHub contribution graph style, you know, graph
[39:25] at the very bottom.
[39:27] And it just shows us over time, like are you
[39:29] actually following some of these best practices?
[39:31] So for me, am I going screen free for some
[39:34] part portion of the morning?
[39:36] Am I, you know, getting my work day goals planned?
[39:40] Am I reflecting?
[39:41] So you can, you know, this is not a complicated
[39:44] app, but you can pop open, you know, your browser
[39:47] dev tools, you can go into the application panel, local
[39:50] storage and we can see that all of our data
[39:53] is kind of here.
[39:54] We've got all of our entries for each of these
[39:57] things.
[39:58] It's all local.
[39:58] It all works like all this will work offline, but
[40:01] it does the trick.
[40:02] Now you can do we can do Q&A, you can
[40:07] do Q&A.
[40:08] So let's spend a few minutes.
[40:10] Do we have a Tom?
[40:11] How do we do this?
[40:11] We have a mic or we're going to do Q&A.
[40:14] Oh, right there.
[40:15] Yeah.
[40:16] So if you do, we'll continue building here.
[40:17] If you want to ask questions, now is your chance
[40:21] to do so.
[40:22] In the meantime, we can continue building your chat about
[40:24] skills if you want to.
[40:25] It's up to you.
[40:27] Awesome.
[40:27] If folks have questions, I'm happy to take it.
[40:29] Otherwise, I'm happy to keep showing you stuff.
[40:34] All right, we got one.
[40:36] It's Anthony.
[40:37] Hey, yeah, a question for you.
[40:39] How would you split up the work between like a
[40:42] flash type model and a pro model?
[40:44] Would you plan in Flash and then implement in pro?
[40:48] How would you split the work?
[40:49] Did you hear that?
[40:50] Yeah, interesting question.
[40:51] So how do you split up between models?
[40:52] Like do you plan in Flash and then implement in
[40:55] pro?
[40:55] Like are you multi model between the Gemini family?
[40:58] Like what's your personal take care?
[41:01] Yeah, I that, that's exactly my workflow.
[41:03] I tend to, and especially if you're trying to optimize
[41:07] for cost, that's a great way to go about it.
[41:10] You can use a lower cost model often for the
[41:13] planning phase, especially if you're trying to like optimize for
[41:16] tokens, use a lower cost model for the planning phase,
[41:19] use a much more capable model for your implementation.
[41:22] And whether that's, you know, going to be one of
[41:25] the Gemini Pro models or Opus or codecs, any of
[41:27] those options can be good for your needs.
[41:29] But I found that that flexibility works well and Copilot
[41:32] and many other tools also let you just like easily
[41:34] switch right between different models for these needs and these
[41:36] different phases, which is which is great.
[41:38] Interesting, I have a question for you.
[41:41] Where does MCP factor into this workflow?
[41:46] That's a great question.
[41:47] I have too many strong opinions on MCP these days.
[41:49] I think that let's.
[41:50] Do it.
[41:51] We actually have some extra time so we can go
[41:53] over a little.
[41:53] Bit right, I, I personally think that so things are,
[41:57] things have been moving so fast, right?
[42:00] And earlier on we would talk about the difference in,
[42:03] you know, hey, MCP was really good for, you know,
[42:06] the, the connectivity right, between data and agents and so
[42:10] on.
[42:10] And I think the people found that very often there
[42:14] are cases where you actually want to CLI instead of
[42:17] an MCP.
[42:18] And we started to see work flows begin to evolve
[42:21] a little bit more because maybe you don't need to
[42:23] have so many tools exposed, Maybe just directly using CLI
[42:26] is going to be a more efficient way to achieve
[42:28] your goals.
[42:29] So I personally feel like we are still in that
[42:32] kind of evolution phase of seeing like, OK, well where
[42:36] is MCP going to be the best fit versus just
[42:38] having people directly use the CLIS for things?
[42:42] This is kind of a contentious area, I feel like
[42:45] because I at one point I did say your MCP
[42:48] server should probably be a skill and ACLI, I kind
[42:51] of still stand by that just because a is are
[42:54] so good at using CLI.
[42:56] The only rejoinder I have to that I was chatting
[43:00] with with Reese, who I think is over at Open
[43:03] Code now about this on on X and he pointed
[43:06] out that the authentication is a real problem and that
[43:10] MCP does this really, really well.
[43:12] And with CLI it's really hard to control permissions for
[43:16] your agent, so I agree with it.
[43:19] But generally speaking I almost use entirely skills.
[43:21] The only MCPS I use is of course work IQ
[43:25] right?
[43:26] Cuz if you're in the Microsoft ecosystem that's like the
[43:28] best thing ever.
[43:29] And then context 7 I always talk.
[43:32] About that, it's great.
[43:32] It's.
[43:33] Amazing, if y'all aren't using the Contact 7 MCP server
[43:36] that's the one thing you should install today and just
[43:39] tell your agent always read the docs before you do
[43:42] anything and it will use contact 7 to read the
[43:44] documentation.
[43:45] Oh, brilliant.
[43:46] I feel I love that, you know, even in Google
[43:48] Cloud, I know in lots of other places people have
[43:51] started to release and maintain more skill packs just because
[43:54] you can.
[43:55] You can get so far these days with making sure
[43:57] that regardless of like what cut off date your agent's
[44:00] data is going to be, you've got up to date
[44:02] documentation, up to date instructions about like where to go,
[44:05] where to find things exactly like what the developer workflow
[44:08] should be.
[44:09] So I'm a I'm a huge fan of skills people
[44:11] don't know that by.
[44:12] Yet yeah, they're they're amazing.
[44:13] And I one of the things, the other thing advantage
[44:15] you talked about this early on is like that they're
[44:18] loaded progressively, right.
[44:19] So one of the things we're all struggling with right
[44:21] now is that the context window is a problem.
[44:24] And honestly, I feel like we need a better solution
[44:26] than a context window in general at some point in
[44:28] the future.
[44:29] This is like a really rudimentary primitive for interacting with
[44:32] LLMS.
[44:33] But the problem is that the context window fills up
[44:36] really fast and MCP, it has to specify all the
[44:39] tools.
[44:40] So if you didn't know, skills are progressively loaded.
[44:43] So what the model gets is like the skill name
[44:46] and a brief description.
[44:47] And then from that it then will load in the
[44:50] skill.
[44:50] And then the skill may point to other files and
[44:53] then it will load in those files.
[44:55] And so it's just really, really economical for token usage,
[44:59] which is more important now.
[45:02] It's becoming more important every day as we are moving
[45:06] from a world of use as much AI as you
[45:08] want to to this is how many tokens you have.
[45:12] Use them wisely.
[45:12] Absolutely.
[45:14] All right.
[45:14] Well, Addie, thank you so very, very much for being
[45:17] here.
[45:17] I learned a ton.
[45:19] I was looking forward to it just for the free
[45:21] training on your skills repo, so I got something out
[45:25] of it.
[45:25] Thank you for being here.
[45:26] Thanks for having me.
[45:27] Appreciate it.
[45:28] That's great.
[45:29] All right.
[45:31] Thank you so much.
[45:31] So we will be right back with our next guest
[45:34] and I guess maybe folks can come chat with you
[45:37] if they want to.
[45:38] Sure thing.
[45:39] All right.
[45:39] Thanks folks.
[45:40] Here we.
[45:45] Go.