Polymorphic Mindset - Marina Santos Haugen - NDC AI 2026

Polymorphic Mindset - Marina Santos Haugen - NDC AI 2026 — NDC Conferences

NDC Conferences

AI-assisted summary of Polymorphic Mindset - Marina Santos Haugen - NDC AI 2026 — original source. Check the original for full context.

Source published:

Key ideas

  • Industry research from McKinsey and BCG reveals that over 85% of enterprises remain stuck at basic AI task delegation, with 40% of agentic initiatives failing due to poor process and organizational design rather than model shortcomings. (4:53)
  • Error magnification scales exponentially across software phases: a single syntax error yields one line of bad code, whereas an unvalidated specification prompt can cascade into tens of thousands of lines of defective code. (7:29)
  • Anthropic engineering guidance advises building modular declarative skills rather than monolithic agents, establishing an AI computing stack where foundation models act as processors, agent clients function as operating systems, and custom skills serve as business applications. (17:27)
  • To combat models generating plausible-looking code that fails in execution, production pipelines must enforce strict verification harnesses that separate author and reviewer agents and use automated linters, tests, and external evaluators. (51:24)

Detailed notes

## Background This presentation was published on YouTube by NDC Conferences on June 26, 2026, following its recording at the NDC AI conference in Oslo, Norway. Delivered by full-stack developer Marina Santos Haugen, the talk explores practical agentic AI workflows, cross-role polymorphic development, and orchestrating parallel AI teams based on her experiences building software over the preceding year.

## TL;DR Haugen presents the 'Polymorphic Mindset,' arguing that modern developers must fluidly adapt across product management, UI design, and engineering roles by leveraging agentic AI workflows. Emphasizing that engineering leverage comes from disciplined systems rather than raw autonomy, she details concrete architectures using Model Context Protocol (MCP) servers, modular markdown skills, and strict verification harnesses to prevent catastrophic, plausible-looking failures. The talk demonstrates practical pipelines including multi-agent code reviews, containerized penetration testing, Excel-driven rapid prototyping, and automated commit clustering. Ultimately, she underscores that developers remain fully accountable for production systems, treating the engineering workflow itself as the core deliverable.

## Atmosphere & style The presentation carries a pragmatic, battle-tested, and intellectually grounded tone, stripping away typical AI hype in favor of hard-won engineering realities. Haugen speaks with approachable candor and reflective humor, pairing transparent admissions of past mistakes—such as deploying 8,000 lines of code solving the wrong problem—with deeply methodical architectural frameworks. Anchored by a retro pixel-art cyberpunk presentation aesthetic, the atmosphere feels like an immersive, behind-the-scenes masterclass that empowers engineers while instilling a strong sense of technical responsibility.

## Bulletin - [04:53](https://www.youtube.com/watch?v=C37Wag4cuhU&t=293s) Industry research from McKinsey and BCG reveals that over 85% of enterprises remain stuck at basic AI task delegation, with 40% of agentic initiatives failing due to poor process and organizational design rather than model shortcomings. - [07:29](https://www.youtube.com/watch?v=C37Wag4cuhU&t=449s) Error magnification scales exponentially across software phases: a single syntax error yields one line of bad code, whereas an unvalidated specification prompt can cascade into tens of thousands of lines of defective code. - [17:27](https://www.youtube.com/watch?v=C37Wag4cuhU&t=1047s) Anthropic engineering guidance advises building modular declarative skills rather than monolithic agents, establishing an AI computing stack where foundation models act as processors, agent clients function as operating systems, and custom skills serve as business applications. - [51:24](https://www.youtube.com/watch?v=C37Wag4cuhU&t=3084s) To combat models generating plausible-looking code that fails in execution, production pipelines must enforce strict verification harnesses that separate author and reviewer agents and use automated linters, tests, and external evaluators.

## Key takeaways - [02:11](https://www.youtube.com/watch?v=C37Wag4cuhU&t=131s) A polymorphic mindset enables developers to fluidly expand their scope into product management, system architecture, and UX design without eliminating cross-functional collaboration. - [04:53](https://www.youtube.com/watch?v=C37Wag4cuhU&t=293s) Strategic enterprise value originates from the structure of the engineering workflow rather than the standalone capabilities of autonomous agents. - [07:29](https://www.youtube.com/watch?v=C37Wag4cuhU&t=449s) Engineers remain strictly accountable for production stability, meaning that blaming an AI agent for flawed code represents an abdication of engineering ownership. - [10:14](https://www.youtube.com/watch?v=C37Wag4cuhU&t=614s) Developers should treat the agentic workflow and its underlying feedback loops as their primary product rather than individual ticket deliverables. - [14:12](https://www.youtube.com/watch?v=C37Wag4cuhU&t=852s) Model Context Protocol (MCP) integrations ground agents in real-time context by connecting them directly to external platforms such as Figma, Linear, Miro, GitHub, and live documentation servers. - [12:37](https://www.youtube.com/watch?v=C37Wag4cuhU&t=757s) Proactive permission controls and continuous context window monitoring (using compaction and clearing) prevent model reasoning degradation and session stalls. - [21:34](https://www.youtube.com/watch?v=C37Wag4cuhU&t=1294s) Verification-before-completion skills are required to block agents from prematurely ending work sessions before passing acceptance criteria, test suites, and type checks. - [26:27](https://www.youtube.com/watch?v=C37Wag4cuhU&t=1587s) Triangulating codebase analysis across parallel exploring agents surfaces reproducible architectural insights and edge cases while reducing individual hallucinations. - [45:36](https://www.youtube.com/watch?v=C37Wag4cuhU&t=2736s) Adopting a Design-First Collaboration model establishes structured review gates across Capabilities, Components, Interactions, and Contracts, catching conceptual misalignments before code authoring begins. - [47:30](https://www.youtube.com/watch?v=C37Wag4cuhU&t=2850s) Committing an Architectural Decision Record (ADR) as the initial repository commit anchors the team's shared mental model and streamlines asynchronous pull request reviews. - [51:24](https://www.youtube.com/watch?v=C37Wag4cuhU&t=3084s) Effective verification harnesses enforce a strict separation between author and reviewer agents, leveraging external evaluators like Google Gemini Flash to independently grade visual and functional execution. - [55:40](https://www.youtube.com/watch?v=C37Wag4cuhU&t=3340s) Automated commit aggregation skills cluster granular micro-commits into pedagogical stages, maintaining a clean git history and easing peer review for massive AI-generated changesets. - [59:09](https://www.youtube.com/watch?v=C37Wag4cuhU&t=3549s) Pairing Git worktrees with modern terminal workspaces and automated port routing allows developers to manage multiple high-touch brainstorms alongside long-running autonomous background agents without branch conflicts.

## Detailed walkthrough ### [00:06](https://www.youtube.com/watch?v=C37Wag4cuhU&t=6s) Introducing the Polymorphic Developer and the Reality of Agentic AI

Marina Santos Haugen introduces herself as a full-stack software engineer and consultant at Kodemaker, holding an academic background in Industrial Economics and Technology Management with a concentration in computer science and artificial intelligence, alongside studies at the NTNU School of Entrepreneurship. Before entering consultancy, she spent seven years at Norway's largest financial services group, DNB, moving across a wide variety of functions including innovation, A/B testing, open banking API platform engineering, and online banking development. Her career followed an unconventional path, starting in business development, moving into experiment management, and subsequently reskilling into software engineering. Because of this eclectic trajectory, she describes herself as inherently polymorphic—someone who thrives on engaging with a little bit of everything.

Over the preceding year and a half, Haugen immersed herself in three distinct client projects focused deeply on agentic AI workflows. Working in these environments demonstrated how much a remarkably small team can accomplish when leveraging fast-moving, high-leverage agentic systems. While industry marketing frequently promises that artificial intelligence will not replace human workers but instead grant them extraordinary leverage, Haugen humorously contrasts that pristine narrative with the unvarnished reality of her own day-to-day life. She displays a slide labeled "Spotted in the wild, the Agentic developer," depicting herself on what was supposed to be a romantic vacation in France, sitting with her laptop perpetually ajar while babysitting autonomous agents running in the background. Acknowledging her husband's patience, she admits she simply cannot help herself because of how transformative it feels when tools allow developers to rapidly morph their capabilities as circumstances dictate.

- Haugen spent seven years at DNB working across business development, experiment management, open banking APIs, and the consumer online bank before retraining as a full-stack engineer. - She completed her formal education in Industrial Economics and Technology Management (focusing on CS and AI) and attended the NTNU School of Entrepreneurship. - As Haugen remarks regarding common industry platitudes versus her vacation reality: “AI won't replace humans, it will give them superpowers.”

---

[02:11](https://www.youtube.com/watch?v=C37Wag4cuhU&t=131s) The Polymorphic Mindset and Redefining Product Roles

Haugen defines the concept of a polymorphic mindset by drawing on the origins of polymorphism, meaning "many forms"—the principle that a single entity can manifest in various ways. In biology, the term denotes morphological variations within the same species; in object-oriented programming, it represents a shared interface executed through differing underlying behaviors, such as an `Animal` contract implemented distinctly by a dog versus a wolf. Applying this concept to human work, Haugen explains that while she remains the same individual, her operational persona shifts radically depending on context—one day operating as a developer locked into deep flow across three monitors, and the next attending a lavish costume masquerade ball at the Palace of Versailles. She likens this adaptability to a video game character equipping different capes, hats, or gear loadouts to gain specialized skill sets on demand.

In conventional digital product development, responsibilities are cleanly divided across a trio of core functions: the Product Manager (PM), the Developer, and the Product Designer. The product manager establishes vision, manages and prioritizes backlogs, aligns stakeholders, and ensures the team builds high-impact outcomes. The developer writes secure, production-grade code, maintains test suites, and performs refactoring. The designer maps user journeys, analyzes quantitative metrics, captures the authentic voice of the user, and crafts user interfaces and experiences. Having personally held responsibilities spanning all three domains, Haugen argues that agentic AI tools empower modern developers to don these different hats and expand far beyond traditional engineering boundaries. Crucially, she stresses that this shift is not an argument against cross-functional collaboration, which remains vital to product success. Rather, agentic workflows dismantle rigid handoffs, transforming teamwork from a sequential, siloed relay into an interconnected, collective effort.

> “So value shifts from executing tasks to shaping systems.” — Marina Santos Haugen

---

[04:53](https://www.youtube.com/watch?v=C37Wag4cuhU&t=293s) Why Workflows Matter: What the Industry Research Reveals

To ground her observations in empirical data, Haugen highlights findings from major management consultancy reports analyzing real-world enterprise AI adoption. A McKinsey report reviewing one year of agentic AI deployments concluded that the strategic differentiator is not the autonomous agents themselves, but the overarching workflow in which they are embedded. Meanwhile, research from Boston Consulting Group (BCG) reveals that over 85% of organizations remain trapped at the basic level of task assistance, information retrieval, and rudimentary delegation, failing to reach the comprehensive workflow reinvention where tangible enterprise value actually resides. This bottleneck explains why over 40% of agentic AI initiatives fail—a breakdown driven entirely by flawed processes and organizational design rather than technical deficiencies in the underlying models. At the executive level, perception is shifting rapidly: 76% of leadership figures now view agentic AI as an active digital co-worker rather than a passive software tool.

Further studies illustrate both the immense upside and the hidden hazards of unguided AI adoption. Internal findings from Procter & Gamble demonstrated that equipping cross-functional teams with AI broke down organizational silos between research and development (R&D) and commercial units, providing a shared conceptual language that allowed AI-augmented teams to deliver three times more breakthrough innovations than traditional teams. However, Haugen cautions that individual AI productivity does not automatically aggregate into organizational value. Current spending is severely lopsided: approximately 93% of corporate AI budgets fund technological infrastructure, while only about 7% is allocated to people, training, and operating models. Without deliberate workflow design, reliance on isolated AI tools can actively corrode team dynamics. Haugen observed this firsthand in a recent project: team members began debating, problem-solving, and sparring almost exclusively with private AI instances, which inadvertently caused peer-to-peer discussion to atrophy. Achieving true business transformation requires actively redesigning operational workflows rather than simply distributing licenses for new software.

- McKinsey's agentic AI research emphasizes: “It's not about agent, it's about the workflow.” - BCG research indicates that more than 85% of companies remain stuck in preliminary task delegation without reinventing end-to-end workflows. - Over 40% of agentic AI projects collapse due to process friction rather than technological limitations. - 76% of surveyed business leaders view agentic systems as collaborative co-workers rather than tools. - P&G reported that cross-functional teams utilizing AI generated three times as many breakthrough discoveries by bridging communication barriers between commercial teams and R&D. - Enterprise expenditure remains heavily skewed, with 93% directed to technology and only 7% invested in people and change management. - Haugen warns about team isolation: “So and without deliberate workflow design, individual AI use can actually erode team work or how a team works.”

---

[07:29](https://www.youtube.com/watch?v=C37Wag4cuhU&t=449s) The Seduction of Speed and the Cost of High-Level Errors

Haugen insists that the rise of agentic tools requires an overhaul in how the industry defines software engineering and the act of coding itself. Developers must never forget that an AI model is merely an instrument; the human engineer maintains ultimate ownership of every line of code deployed and full accountability for system stability. Blaming the AI when an application breaks is an abdication of professional duty. Haugen argues that when an agent generates substandard code, the failure almost invariably stems from poor human guidance, weak constraints, or an undisciplined process. The modern hazard for engineers is the intoxicating seduction of velocity—the illusion of massive forward momentum simply because an autonomous tool generated thousands of lines of syntax in response to a single prompt, even if the resulting architecture is fundamentally flawed.

```mermaid flowchart TD accTitle: Error Amplification Ladder in Agentic Development accDescr: Diagram illustrating how a single error at higher levels of abstraction amplifies into exponential quantities of bad code downstream.

subgraph Foundation ["System Roots"] Infra["1 Bad Line of Core Infrastructure / System Prompt<br/><b>100,000s lines of bad code</b>"] Spec["1 Bad Line of Specification / Problem Definition<br/><b>10,000s lines of bad code</b>"] end

subgraph Analysis ["Upstream Planning"] Research["1 Bad Line of Research<br/><b>1,000+ lines of bad code</b>"] Plan["1 Bad Line of Implementation Plan<br/><b>10 to 100 lines of bad code</b>"] end

subgraph Execution ["Downstream Code"] Code["1 Bad Line of Syntax<br/><b>1 line of bad code</b>"] end

Infra --> Spec Spec --> Research Research --> Plan Plan --> Code ```

To illustrate why human attention must migrate upstream, Haugen presents an error amplification model showing how a minor misunderstanding early on cascades into exponential volumes of technical debt: - One bad line of syntax produces exactly one bad line of code. - One bad line in an implementation plan generates between 10 and 100 lines of faulty code. - One bad line of research yields over 1,000 lines of misplaced code. - One bad line of specification—where the engineer misunderstands the problem domain or system architecture—results in tens of thousands of bad lines. - One bad line of core infrastructure, such as a flawed system instruction or context prompt injected into every cloud session, amplifies into hundreds of thousands of lines of defective code across an organization.

Haugen candidly shares a painful personal mistake from a project where, being relatively new to the codebase, she fundamentally misjudged the underlying system architecture during her initial research phase. Falling into what she terms the "implementation trap," she leaned on autonomous agents to push through development, only to find herself holding two colossal pull requests—one for backend and one for frontend—totaling 8,000 lines of code that solved the wrong problem. She ended up trapped in an agonizing refactoring cycle, noting that generating massive volumes of code is the most expensive and time-consuming way possible to realize that your initial mental model was flawed.

> “So, when something fails, it's easy to blame like, 'Oh, the AI did that so wrong.' But, I would argue that that's your responsibility, and that if it produces something shitty, then it's actually your fault, because maybe you haven't guided it or had the good a good workflow.” — Marina Santos Haugen

---

[10:14](https://www.youtube.com/watch?v=C37Wag4cuhU&t=614s) Anatomy of a Workflow: Foundations and Configuration

Rather than viewing features or individual tickets as the primary deliverable, Haugen advocates treating the development workflow itself as the real product. Every task assigned to an engineer functions as an experimental verification of whether their workflow is resilient and effective. Haugen structures her personal operating rhythm around a four-stage lifecycle: Exploration, Planning, Coding, and Verification. Crucially, this is not a rigid waterfall pipeline; it operates as an iterative, non-linear loop where an engineer frequently jumps backward or forward between phases as new insights emerge.

```mermaid flowchart TD accTitle: Anatomy of an Agentic Workflow accDescr: The iterative four-phase development loop supported by core technical foundations.

subgraph Loop ["Iterative Workflow Loop"] Explore["Exploration Phase"] Plan["Planning Phase"] Code["Coding Phase"] Verify["Verification Phase"]

Explore <--> Plan Plan <--> Code Code <--> Verify Verify <--> Explore end

subgraph Foundations ["Core Technical Foundations"] Config["Configuration<br/>Personal flow, permissions & insight boxes"] Skills["Skills & Plugins<br/>Task recipes in Markdown & bundled hooks"] MCP["Model Context Protocol (MCP)<br/>Universal connectivity to external tools"] end

Foundations -.-> Loop ```

This workflow is supported by three core technical foundations: 1. **Configuration:** Tailoring the agent environment to match personal working preferences, acknowledging that what represents an optimal flow for one developer differs for another. 2. **Skills and Plugins:** A skill acts as a declarative recipe for a discrete task written in standard Markdown. Plugins bundle these markdown skills alongside operational hooks and Model Context Protocol (MCP) integrations, creating modular packages that can be easily shared, installed, and reused across environments. 3. **Model Context Protocol (MCP):** Functioning as the universal "USB-C port" of the AI ecosystem, MCP provides a standardized protocol that connects local or autonomous agents directly to external tools, databases, and third-party APIs.

Diving into the practical setup of the configuration layer, Haugen highlights the necessity of active permission management to avoid what she calls "death by allow/deny prompts"—the constant disruption of an agent halting execution to ask for user approval on routine file reads and terminal commands. Engineers can audit their active permission rules using commands like `/permissions` or configure automated execution modes (such as running auto-mode flags or automated runners) so agents can operate without manual intervention. Additionally, she establishes dedicated "insight boxes" within her environment to capture critical system observations and context as her agents work.

> “Every time you get a task, you can think of it as just a test that your workflow works and that it's good.” — Marina Santos Haugen

[12:37](https://www.youtube.com/watch?v=C37Wag4cuhU&t=757s) Explanatory Output, CLAUDE.md Maintenance, and Context Management

When working with an AI coding agent, visibility into its decision-making process is critical, especially when stepping into an unfamiliar repository. By configuring the agent's output style to explanatory via `/config`, developers can surface the underlying patterns and reasoning behind every decision the agent makes, marked clearly in the output. This pattern drastically flattens the learning curve for new codebases.

Maintaining the agent's system guidance files is equally vital. Rather than treating `CLAUDE.md` as static documentation, it should be continuously updated alongside the project infrastructure. Using a plugin like `claude-md-management`, developers can run automated skills to evaluate and adapt the configuration:

```mermaid flowchart TD accTitle: CLAUDE.md Management and Context Workflow accDescr: Flow showing evaluation, revision, and context management loops for CLAUDE.md files.

subgraph EvaluationLoop["Configuration Maintenance"] A["CLAUDE.md File"] --> B["claude-md-improver"] B --> C["Score & Grading Recommendations"] D["Interactive Session Learnings"] --> E["revise-claude-md"] E --> A end

subgraph ContextHygiene["Context Management"] F["Active Session Context"] --> G{"Context Threshold Warning"} G -->|"Context Depleted"| H["Run /compact or /clear"] G -->|"Sufficient Context"| I["High-Quality Code Output"] end ```

Active context management directly dictates the resulting code quality. As the context window fills up, model degradation leads to noticeably worse output. Keeping a close eye on the environment by displaying both the current working directory and a real-time context warning in the status line helps prevent this degradation.

- The `claude-md-improver` skill grades the existing `CLAUDE.md` file and outputs targeted recommendations for optimization. - The `revise-claude-md` command captures hard-won lessons, corrections, and mistakes from an active session and records them into the documentation. - Built-in commands like `/compact` and `/clear` are used frequently to maintain a clean context window and ensure consistent reasoning quality.

---

[14:12](https://www.youtube.com/watch?v=C37Wag4cuhU&t=852s) Expanding Capabilities with MCP Servers

Model Context Protocol (MCP) servers bridge the agent with external tooling across design, issue tracking, documentation, and security. By running `/mcp`, developers can inspect their active integrations and orchestrate cross-tool workflows from the terminal. In product design, connecting to Figma allows the agent to fetch and inspect layouts, while Miro integrations let it parse whiteboards and map out complex architectural diagrams. On the project management side, integrations with Linear, Jira, and GitHub Issues automate the process of filing thorough bug reports complete with screenshots and repro steps.

```mermaid flowchart LR accTitle: MCP Server Architecture accDescr: Diagram illustrating MCP servers connected to Claude Code spanning design, issues, docs, and testing.

subgraph AgentCore["Agent Workspace"] CC["Claude Code"] end

subgraph MCPTools["MCP Integrations"] direction TB Design["Design: Figma, Miro"] Issues["Tracking: Linear, Jira, GitHub"] Docs["Docs: Context7, Notion"] SecTest["Security & Test: Semgrep, Playwright"] end

CC <--> Design CC <--> Issues CC <--> Docs CC <--> SecTest ```

Because foundation models suffer from strict training cut-off dates, documentation MCP servers like Context7 prove invaluable for dependency management. Context7 provides real-time access to upstream library changes—such as Next.js documentation refreshed within the last nine hours—making it straightforward to identify breaking changes, evaluate patch releases, or choose ecosystem tools like Agent Browser.

For complex system specifications, MCP servers bridge the gap between messy design artifacts and clean code. In one project instance, an overwhelming decision tree on Miro was parsed by Claude via MCP and transformed into structured text, detailing the happy path and all branching conditions so it could be easily shared with non-technical stakeholders and product managers. Similarly, security is integrated directly into the authoring loop: the Semgrep MCP server scans the agent’s code edits against OWASP Top 10 vulnerabilities in real time, prompting immediate remediation before issues ever reach a pull request.

---

[17:27](https://www.youtube.com/watch?v=C37Wag4cuhU&t=1047s) The Shift from Agents to Skills: Processors, OS, and Applications

The architectural focus in generative AI has pivoted decisively toward specialized skills rather than monolithic agents. Reflecting on guidance shared by Anthropic engineers at the AI Engineer conference in late 2025, Marina emphasizes that the primary leverage for developers does not come from waiting for newer base models:

> “Anthropic had two of their employees in uh uh AI engineer, a conference and YouTube channel, and they was very clear, like don't build agents, build skills instead.”

Under this mental model, AI components mirror traditional computing architecture:

| Computing Layer | AI Equivalent | Role and Differentiation | |:--- |:--- |:--- | | **Processor** | **Foundation Models** | Raw compute engine; performance is rapidly commoditizing as smaller models reach parity with frontier models. | | **Operating System** | **Agent Clients** | Context wrappers and prompting environments (e.g., Claude Code) handling input/output conventions. | | **Applications** | **Skills & Plugins** | Specialized domain logic, custom constraints, and repeatable workflows where unique business value lives. |

Building bespoke skills requires treating the workflow itself as a product. For her own presentations, Marina developed a custom `pixel-theme` skill to generate pixel-art landscapes and underwater illustrations that match a strict, cohesive retro palette. Achieving this reliability required moving away from unpredictable raw prompting:

> “It took like at least 15 iterations before I was any happy or it actually started to produce good results.”

While the agent ecosystem provides out-of-the-box bundled commands—such as `/batch` for executing multi-file refactors like migrating UI components from Vue to React, `/debug`, `/simplify`, and `/loop`—caution is required when looking outside official ecosystems. Third-party skill marketplaces pose security risks; the recommended pattern is inspecting open-source skill repositories (such as Anthropic’s official agent skills on GitHub) for architectural inspiration, and then hand-crafting tailored skills locally.

---

[21:34](https://www.youtube.com/watch?v=C37Wag4cuhU&t=1294s) The "Superpowers" Skill Suite: Planning, Implementation, Scaling, and Quality

The "Superpowers" suite organizes 14 distinct skills across four operational phases: planning, implementation, scaling, and quality control. Rather than relying on standard terminal text output, the `brainstorm` planning skill generates an interactive HTML page. This visual spec interface allows developers to review architecture options, compare filtering UI choices (such as toggle buttons versus dropdown selectors), and select design paths visually before committing to code generation.

```mermaid flowchart LR accTitle: Superpowers Workflow Phases accDescr: Four-phase development cycle of the Superpowers skill suite covering planning, implementation, scaling, and quality.

subgraph Planning["1. Planning"] P1["brainstorm (HTML Spec)"] P2["writing-plans (Step Breakdown)"] end

subgraph Implementation["2. Implementation"] I1["Test-Driven Development (TDD)"] I2["Systematic Debugging"] end

subgraph Scaling["3. Scaling"] S1["Sub-agent Development"] S2["Git Worktrees"] end

subgraph Quality["4. Quality"] Q1["verification-before-completion"] Q2["requesting / receiving code review"] end

Planning --> Implementation Implementation --> Scaling Scaling --> Quality ```

During implementation, developers rely on structured skills like test-driven development and systematic debugging to ensure new code remains testable. When scaling across large tasks, sub-agent-driven development spins up separate worker agents, each running within its own isolated context window and utilizing separate Git worktrees to avoid polluting the primary branch.

The quality phase tackles the model's natural tendency to take shortcuts. Left to its own devices, an AI agent will often prematurely announce task completion just to terminate the session:

> “AI an agent will often kind of like say, 'Yeah, I'm done.' in a way because it just wants to finish the session. But then if you trigger this skill, it has to actually verify, okay, like run all the test, all the linting, type check, and actually verify that you are actually done with the acceptance criteria.”

- The `writing-plans` skill breaks incoming tasks down into isolated, testable implementation units. - The `verification-before-completion` skill halts the agent from declaring victory until all automated test suites, linting rules, type checks, and acceptance criteria pass completely. - Skills like `requesting-code-review` and `receiving-code-review` provide dedicated workflows for pre-submission checks and brainstorming fixes for peer review comments received on open pull requests.

[24:04](https://www.youtube.com/watch?v=C37Wag4cuhU&t=1444s) Front-End Design Skill and Aesthetic Direction

When AI models are asked to build user interfaces without explicit styling guidance, the output is notoriously generic. As Marina Santos Haugen observes: “With AI, it tends to kind of like make everything look like AI-produced stuff. It's like very sloppy and just one design.” The `front-end design` skill addresses this by forcing the model to understand the problem space, the target users, and the brand identity before writing UI code.

```mermaid flowchart TD accTitle: Comparison of Brute-Force vs Skill-Guided UI Workflows accDescr: Diagram contrasting an unguided prompt producing generic UI with a multi-step design skill producing a custom theme.

subgraph BF["Brute Force Approach"] A["Prompt: Build user story 1, create topic"] --> B["Writes generic code directly"] B --> C["Result: Super boring black-and-white Next.js UI"] end

subgraph SD["Guided Design Skill Approach"] D["Prompt: Brainstorm aesthetic direction first"] --> E["Opens browser with 3 visual alternatives"] E --> F["Select 'Clinical reference' + paramedic palette"] F --> G["Export to design-theme-docs"] G --> H["Front-End Design Skill implements UI"] H --> I["Result: Polished medical journal layout with ambulance red/white tones"] end ```

To demonstrate the difference, Haugen presents two distinct sessions given the identical functional requirement—building a feature for a paramedic learning platform—but initiated with different workflows:

1. **Brute Force:** Prompted simply with "build user story one, create topic." The model immediately ran off, wrote code, and announced it was done. The outcome was a lifeless, stark black-and-white Next.js starter page. 2. **Aesthetic Direction Workflow:** Haugen instructed the model to "start with brainstorming for an aesthetic direction, and then a front-end design to implement it." The agent opened a browser view and displayed three distinct visual concepts. Haugen selected a clinical reference direction modeled after medical publishing platforms, tailoring typography, paper-like background tones, and an ambulance-inspired red-and-white color palette.

Once selected, Haugen instructed the agent to save the specifications into a persistent `design-theme-docs` file so the design language could be reused consistently across the entire application.

---

[26:27](https://www.youtube.com/watch?v=C37Wag4cuhU&t=1587s) The 7-Phase Feature Dev Pipeline

Beyond the granular Superpowers toolkit, Haugen introduces `feature dev`, an end-to-end, seven-stage pipeline engineered to tackle complete feature implementations while keeping the developer's mental model aligned with the AI.

```mermaid flowchart TD accTitle: Seven-Phase Feature Dev Pipeline accDescr: Linear workflow showing the seven stages of the feature dev pipeline including multi-agent exploration and review.

subgraph Prep["Planning & Discovery"] S1["1. Discovery: Capture ask & build todo list"] --> S2["2. Exploring: Spin off 2-3 parallel agents"] S2 --> S3["3. Clarification: HARD STOP (user input required)"] end

subgraph Exec["Architecture & Build"] S3 --> S4["4. Architecture: Present up to 3 options with pros/cons"] S4 --> S5["5. Implementation: Full execution with aligned mental model"] end

subgraph Verify["Quality & Completion"] S5 --> S6["6. Review: 3 agents evaluate simplicity, correctness, conventions"] S6 --> S7["7. Wrap-up: Final closure"] end ```

The pipeline enforces structured checkpoints rather than letting the AI run unconstrained: - **Phase 1: Discovery** — Captures requirements and compiles an execution task list. - **Phase 2: Exploring** — Spins off two to three parallel agents to investigate the codebase. Haugen emphasizes the power of parallel analysis: “When you have many different agents at the same time, if they come back with the same findings, then you are triangulating data. So, you can be very sure that it's a good idea or it's a nice bug they found or whatever.” - **Phase 3: Clarification** — Serves as a strict **hard stop**. The pipeline refuses to proceed without direct developer input, prompting questions to resolve edge cases and ambiguities. - **Phase 4: Architecture** — Generates up to three alternative architectural approaches, complete with trade-offs, pros, and cons for the developer to evaluate. - **Phase 5: Implementation** — Having aligned the mental model through the prior steps, the agent executes the build: “I have been with you the whole way, and now I know actually my mental model is the same as yours. You can go ahead.” - **Phase 6: Review** — Spawns three separate reviewer agents inspecting the code against simplicity, correctness, and repo-specific conventions. - **Phase 7: Wrap Up** — Concludes the implementation run.

---

[28:23](https://www.youtube.com/watch?v=C37Wag4cuhU&t=1703s) Code Review Workflows: PR-Level vs. Local Terminal

Haugen contrasts two separate review skills designed for different stages of the development cycle:

| Feature / Trait | Automated GitHub PR Review Skill | Local Interactive Review Skill | |:--- |:--- |:--- | | **Execution Context** | Runs against open pull requests directly on GitHub | Executed locally in the terminal as a final feature wrap-up step | | **Agent Architecture** | Multi-agent parallel review | Multi-agent parallel review | | **Trigger / Behavior** | Automatically posts a comment directly to the PR | Outputs structured review summaries to the terminal stdout | | **Strictness Threshold**| Posts only if the evaluation score exceeds 80% | Customizable checks (e.g., scoping strictly to commented-out code removal) | | **Customization** | Zero configuration / strict preset rules | High customization to focus on specific code concerns |

Haugen shares an anecdote where a colleague was startled when the automated bot unceremoniously commented directly onto his pull request. Haugen points out that this behavior is explicitly defined in the skill definition, operating under a strict 80% scoring threshold before it will write to GitHub. In contrast, Haugen relies heavily on the local review skill to catch lingering debug comments and formatting issues before pushing code upstream.

---

[29:42](https://www.youtube.com/watch?v=C37Wag4cuhU&t=1782s) Document Analysis and Accelerated UI Prototyping

While document processing skills within the Claude Cowork desktop app are often treated as tools for business analysts and product management, Haugen shows how transformative they are for core development work.

```mermaid flowchart LR accTitle: Excel to Interactive Prototype Workflow accDescr: Workflow from complex spreadsheet analysis to live deployed interactive prototype for stakeholders.

XLS["Excel Spec: 56 cols, 370+ rows, M/CM/Optional flags"] --> DS["Doc Skills: Extract & cross-ref eForm SDK on GitHub"] DS --> PROTO["Next.js / Web Artifact Prototype"] PROTO --> PM["Product Manager clicks through dynamic fields & groupings"] ```

Haugen describes an assignment involving a massive Excel specification containing 56 columns and more than 370 rows. The requirement was to parse specific rows (such as rows 16 and 29) to construct a dynamic wizard interface, mapping out fields marked as mandatory (`M`), conditional mandatory (`CM`), or optional. If a field was labeled `code`, its valid values were absent from the sheet and had to be cross-referenced against an external GitHub repository containing the eForm SDK.

Instead of spending days manually cross-referencing tables: - The document skill ingested the spreadsheet, parsed the conditional fields, matched missing codes against the eForm SDK, and output the data structure. - Leveraging web artifacts, Haugen immediately generated a fully interactive prototype and deployed it for the product manager. - The PM could click through the prototype, expand code dropdowns to inspect options, determine which values belonged in the design sketch, and evaluate suggested groupings for form fields in real time.

---

[32:55](https://www.youtube.com/watch?v=C37Wag4cuhU&t=1975s) Security Audits, Automation Recommenders, and Custom Skills

Beyond design and documentation, Haugen highlights specialized tools and custom agent configurations that enhance development velocity and security:

- **Security Review Skill:** Can be triggered on demand or integrated directly into CI/CD pipelines. Haugen demonstrates running it across 12 files at once, outputting vulnerabilities categorized into high, medium, and low severity alongside remediation advice. - **Claude Automation Recommender:** A meta-skill that inspects developer interaction history and environment configurations. It proposes: - **Hooks & Safety Guardrails:** For example, adding a `pre-tool-use` hook that explicitly blocks Claude from modifying `.env` secrets. - **Permission Housekeeping:** Scanning prompt history to identify prompts or commands the developer consistently approves, suggesting automated rules for them. - Sub-agents, skills, and Model Context Protocol (MCP) servers tailored to the project. - **Custom Skills:** Haugen showcases several purpose-built workflows, remarking: “Here it's your imagination that is the limit, really.” - *Test Implementation Skill:* Maintains test user fixtures and route mappings. Haugen pastes a Linear ticket or GitHub PR URL, and the skill verifies that all acceptance criteria are met, runs a demo recorder to capture a video or GIF, and posts a completion summary directly to Slack. - *Dependency Update Skill:* Automatically queries the Context7 MCP server to retrieve official, up-to-date framework and library documentation before bumping packages.

[035:45] Skill Creator and Quality Checks for UI Design Inspiration

Marina explains that building custom skills does not have to be done from scratch or by guesswork; developers can leverage a specialized "skill creator" meta-tool. This utility helps establish the correct file structure, define required input variables, and formulate precise description triggers so the agent knows exactly when to invoke the skill. Once drafted, the skill can be verified against a "writing skills" checker that tests execution and offers targeted feedback, acting as an automated quality check.

To illustrate practical usage, Marina shares an example from her work building a CRM system. She found herself frustrated because the AI kept proposing UI components and styling that clashed with the project's established design theme. To solve this, she designed a four-step custom skill:

```mermaid flowchart LR accTitle: UI Component Inspiration and Security Skill accDescr: A four-step pipeline showing theme analysis, community component search, vulnerability scanning, and alternative synthesis.

subgraph S1["1. Context & Retrieval"] A["Read Design Theme"] --> B["Search 21st.dev via MCP"] end subgraph S2["2. Validation & Output"] B --> C["Scan for React Top 10 Vulnerabilities"] C --> D["Synthesize 1–4 Alternatives"] end ```

Acting as her own designer on a solo project, she used 21st.dev—an open community platform where designers and developers share front-end components—as an inspiration source via an MCP server. Because public registries carry inherent risks, step three explicitly mandated scanning fetched components for common security flaws, specifically checking against the React Top 10 vulnerabilities. In the final step, the agent synthesized one to four safe design alternatives and documented them in a dedicated research file, allowing her to pick interactive elements like an empty-state component, request tweaks through chat, and immediately integrate the code.

[037:59] The Pedagogical PR Review Skill

Reviewing pull requests generated by agentic workflows introduces a new friction: AI systems frequently produce massive, multi-ticket changesets that are difficult for human reviewers to grok without a shared mental model. Marina ran into this challenge while working in an unfamiliar codebase, prompting her to create a "pedagogical PR review" skill designed to turn pull request audits into personalized learning sessions.

She demonstrates triggering the skill directly with a GitHub pull request number. The example shown is an enormous PR touching 90 files, delivering four distinct tickets, and deleting 41,000 lines of code—which she jokes made it “actually a good day at work.” Rather than dumping a wall of raw diffs, the skill first generates a high-level orientation summary, occasionally rendering ASCII diagrams to map architectural dependencies. It then proposes a structured walkthrough—breaking the massive review into 13 manageable, domain-grouped stages.

As it steps through the code file-by-file or domain-by-domain, the agent explains the reasoning behind each modification, points out potential edge cases, and compiles a running to-do list of suspected issues at the bottom. Once the full walkthrough concludes, Marina and the agent systematically revisit each item on the to-do list to verify whether it warrants an actionable comment on GitHub.

[039:46] Containerized Penetration Testing with Kali Linux MCP

As a solo developer handling full-stack delivery without dedicated security staff, Marina turned to containerized penetration testing to verify her system's defenses. Emphasizing that self-run scripts do not replace seasoned human professionals, she points out the empowering shift that agentic tools bring: “And I'm not saying it should kind of like erstatte [replace]... but just like it's nice that you can do a small penetration test from home in a container, and like you can find some vulnerabilities by yourself.”

Using an MCP server connected to a Kali Linux environment running inside Docker Desktop, the agent gained access to 11 security utilities: - Exposed port scanners - Web vulnerability analyzers - Directory brute-forcers - SQL injection testers - Specialized CMS tools like WordPress scanners (which the agent repurposed to fuzz common administrative paths such as `/admin`) - Password-cracking engines with colorful names like Hydra and John the Ripper ("John crack")

Once unleashed in the container, the agent actively probed her local deployment for weaknesses and surfaced actionable remediation steps. However, Marina issues a critical warning regarding automated tooling installation: the first time she asked Claude to connect to Kali, it located an unofficial MCP repository published by a random GitHub user rather than the verified, official project. She stresses that developers must remain vigilant, audit external connections, and manually inspect whatever packages the LLM pulls into the loop.

[041:56] The End-to-End Workflow: Exploring and Scoping Product Specs

Marina frames her overarching development pipeline across distinct phases: exploration/research, planning, coding, and verification. In the exploration phase, she operates primarily in product management and design modes, utilizing tools like Claude Desktop, Cowork, and design-first brainstorming workflows.

To demonstrate, she takes a real-world feature request from her CRM project: a user submitted an issue asking to “add a period filter to the leads board,” complete with a screenshot marking where they believed the dropdown should sit. Marina highlights a fundamental engineering and product principle: “And as we know, never listen to solution suggestions from users. First, understand the problem and the need.”

```mermaid flowchart TD accTitle: Exploration to Planning Phase Flow accDescr: Pipeline from user feature suggestion through Cowork plugins, specification creation, and GitHub issue breakdown.

A["Raw User Issue<br/>(Period Filter Request)"] --> B["Cowork Plugins<br/>(PM, Legal, Finance Context)"] B --> C["Writing Plans Skill<br/>(Spec Generation)"] C --> D["Product Requirements Doc<br/>(Goals, Non-Goals, Stories, Edge Cases)"] D --> E["GitHub MCP Server<br/>(Scoped Subtasks & Issue Comments)"] ```

To drill down into the core user need, she used Cowork plugins, which provide specialized domain personas spanning legal, finance, data science, engineering, and product management. Putting on her PM hat, she invoked a plan-writing skill with the repository and issue context attached. The agent generated a comprehensive Product Requirements Document (PRD) detailing problem definitions, explicit goals, non-goals, user stories, edge cases, requirements, and prioritized acceptance criteria. Armed with this spec, she used the GitHub MCP server to post the structured breakdown directly into the GitHub issue, creating granular subtasks so downstream coding agents would have complete context before touching any code.

[045:36] Design Mockups and Design-First Architecture Collaboration

With the "why" and "what" firmly established, the workflow turns to resolving the "how"—the visual presentation and the underlying technical architecture. To finalize the UI without leaving her agentic setup, Marina used the model’s environment to generate an interactive mockup directly from her codebase. Recognizing that the company tracked performance via half-year OKRs and that users only needed to evaluate concluded work, the agent concluded that placing a global filter across the entire board was unnecessary. Instead, it positioned the period filter specifically within the completed ("ferdig") lane. Marina captured a screenshot of this rendered preview and attached it straight to the tracking ticket so implementing sub-agents would have clear visual acceptance criteria.

For the system architecture, Marina addresses the risk of letting agents emit large volumes of code without human alignment: “Again, with these AI agents, sometimes it's like so important to have a combined mental model with the AI.”

To bridge this gap, she implemented a custom skill inspired by an article by Rahul Garg titled "Design-First Collaboration." The skill simulates a structured, level-by-level whiteboard exercise between the developer and the AI, allowing the human to steer or halt the architectural reasoning at any step: - **Capabilities:** Defining precisely what the feature does and its operational boundaries. - **Components:** Mapping out which specific functional pieces, modules, and data pipelines are needed to support those capabilities.

[47:30](https://www.youtube.com/watch?v=C37Wag4cuhU&t=2850s) Four-Level Planning and Architecture Decision Records

Marina Santos Haugen walks through the final stages of the planning phase: mapping out interactions (how all pieces communicate) and contracts (interfaces, data schemas, and contracts between components). Catching architectural issues early is critical for project velocity and code maintainability. As Haugen explains, “So, this is kind of the cheapest moment to find errors and find misalignments because you are in the planning phase and it's taking you through like an overview and not like these huge PRs with 8,000 lines of code, then it's very expensive to find misalignments.”

```mermaid flowchart TD accTitle: Four-Level Planning and ADR Workflow accDescr: Step-by-step gate reviews leading to an architectural decision record and multi-agent execution. subgraph Plan ["Planning Review Gates"] L1["Level 1: Capabilities"] -->|"Hard Stop Approval"| L2["Level 2: Components"] L2 -->|"Review Gate"| L3["Level 3: Interactions"] L3 --> L4["Level 4: Contracts"] end subgraph Output ["Deliverables & Handoff"] L4 --> ADR["Architectural Decision Record (ADR)<br/>1-Page Commit"] ADR --> TL["Team Lead Agent"] end subgraph Execution ["Parallel Work Streams"] TL --> BE["Backend Agent<br/>(Issues #89, #90)"] TL --> FE["Frontend Agent"] BE --> QA["Testing Agents"] FE --> QA end ```

The tool executes a skill that inserts a hard stop after Level 1 (capabilities), allowing the human to confirm alignment before proceeding to Level 2 (components), and then continuing through Levels 3 and 4 with human review gates at every step. This process concludes by generating an Architectural Decision Record (ADR), which becomes the developer's very first commit as a single-page document. Presenting an ADR makes collaboration effortless: peers only need to read one page that outlines evaluated approaches, why a specific choice was selected, and where potential system misalignments might hide, making feedback cheap and fast.

[49:00](https://www.youtube.com/watch?v=C37Wag4cuhU&t=2940s) Orchestrating Parallel Agent Teams and Iterative Refinement

Once full context and architectural boundaries are established, the system partitions work into issue tickets and spins up agent teams working in parallel. Haugen interacts solely with the team lead agent, who directs a backend agent (working on GitHub issues #89 and #90), a frontend agent, and testing agents tasked with running test suites until every single check turns green. While tested under what was initially a beta feature called "orchestrating a team of agents," Haugen notes it has matured significantly.

However, Haugen cautions developers about initial outputs: “So, but don't expect it to be perfect on the first try. You have to iterate with it.” Real-world execution demands fine-tuning. For instance, when an agent implemented a UI filter that felt visually cramped right next to the dashboard metrics, Haugen iterated on the layout, relocating the filter downward to give the stats more breathing room. The verification loop then loads a testing skill that reads the GitHub issue's acceptance criteria, drives a headless browser via Chrome to exercise each requirement sequentially, and posts the test execution findings back to the parent GitHub issue as a summary.

[51:24](https://www.youtube.com/watch?v=C37Wag4cuhU&t=3084s) The Verify Phase and Multi-Model Evaluation

Haugen identifies verification as holding the greatest untapped potential in agentic workflows, admitting she spent months manually double-checking code before realizing how much could be delegated. She cites Anthropic's guidance to underscore the danger of passive acceptance: “Anthropic's official best practice tip number one is actually like, without verification, Claude may produce plausible looking code that doesn't actually work.”

To build a resilient verification harness, Haugen combines several complementary layers: - **Separation of Author and Reviewer:** Never use the same agent context window to both write code and review it; use tools such as the PR review toolkit instead. - **Proof Before Claim:** Requiring strict verification before completion, running all automated test suites, linters, and type-checkers. - **External Multi-Model Judges:** Using Google's Gemini Flash model via OpenRouter as an independent judge, particularly for auditing UI designs and slides against structured scorecards. - **Visual and Browser Verification:** Combining an agentic Chrome browser via Playwright with isolated UI documentation tools like React Cosmos and Storybook.

When auditing presentation slides, Gemini inspects exported PNGs via the OpenRouter API across eight distinct evaluation categories. If a metric like "visual polish" receives a low score, the agent pinpoints specific design flaws and offers to trigger a pixel-art theme brainstorming agent to generate fresh illustrations with Nano Banana. Furthermore, isolating components within React Cosmos forces clean modular design, ensuring developers can inspect all component variants in isolation before stitching them into an existing codebase.

[55:40](https://www.youtube.com/watch?v=C37Wag4cuhU&t=3340s) The Autonomous Flow Skill and Conductor Orchestration

Under intense two-week delivery pressures, Haugen developed an end-to-end "autonomous flow skill" to automate verification before human intervention. Rather than manually inspecting intermediate changes, the system chains automated verification stages together: it self-verifies using test and lint checks, launches six distinct code-review agents that summarize and remediate their own findings, and executes automated Playwright browser tests against acceptance criteria.

```mermaid flowchart LR accTitle: Autonomous Flow and Commit Dance Pipeline accDescr: Pipeline executing automated checks, commit squashing, PR creation, and bot reviews before human sign-off. subgraph PrePR ["Pre-PR Automation"] A["Self-Verify<br/>(Tests & Lint)"] --> B["6x Review Agents<br/>(Fix & Summarize)"] B --> C["Headless Browser<br/>(Acceptance Checks)"] C --> D["Commit Dance<br/>(Pedagogical Clusters)"] end subgraph GitHubFlow ["GitHub & Bot Interaction"] D --> E["Push PR with<br/>Clean Narrative"] E --> F["GitHub Bot Review"] F --> G["Agent Reads &<br/>Fixes Bot Feedback"] end G --> H["Human Reviewer<br/>Jumps In"] ```

To solve the issue of fragmented git histories created by parallel agents, Haugen created a skill called "commit dance":

- Gathers all 30+ micro-commits into a temporary history file. - Clusters changes into logical, pedagogically sound groupings to produce a readable, clean git narrative. - Opens a GitHub pull request with that refined commit sequence. - Triggers GitHub automated review bots, has the agent read the bot comments, implements the requested changes, and replies to the bot directly.

Only after the bot reviews and automated fixes pass does the human step in to review what remains an unmerged work-in-progress PR. To produce slide decks and documentation at scale, Haugen uses Conductor to manage parallel Claude agent sessions. This setup let her iterate through 136 merged pull requests for individual slides—handling language translation, outdated content checks, and layout adjustments across separate, easily mergeable branches with full file and diff visibility.

[59:09](https://www.youtube.com/watch?v=C37Wag4cuhU&t=3549s) Streamlining Workspaces with Warp, Git Worktrees, and Portless

Marina Santos Haugen demonstrates how she sets up local testing environments directly within chat sessions or terminal configurations to quickly validate generated app components. She highlights Warp, a modern terminal, which allows her to spin up a complete, multi-part development environment with a single click. Her preconfigured tab setup automatically opens up the project backlog, an active cloud session with access to Backend for Frontend (BFF) disk logs, a Cloudflare Tunnel handling authentication with their identity provider, the running web application for direct testing, and Cosmos for inspecting individual components.

To isolate concurrent tasks without stepping on active work, she combines this workflow with Git worktrees across different features. This approach launches matching backend, frontend, and Cosmos instances for each branch. Rather than juggling conflicting local port numbers across multiple active features, she uses Portless (by Vercel), which assigns dedicated URLs to each feature branch.

```mermaid flowchart TD accTitle: Multi-Feature Local Development Setup accDescr: Diagram showing how Warp tabs and Git worktrees connect to individual services via Portless URLs.

subgraph WarpEnv["Warp Terminal Environment"] Backlog["Backlog View"] BFF["Cloud Session / BFF Logs"] Tunnel["Auth Tunnel (IdP)"] Cosmos["Cosmos Component Inspector"] end

subgraph Worktrees["Git Worktrees & Portless Routing"] WT1["Worktree: Feature 1"] --> URL1["Portless URL 1 (e.g. feature-1.local)"] WT2["Worktree: Feature 2"] --> URL2["Portless URL 2 (e.g. feature-2.local)"] end

WarpEnv --> Worktrees ```

- Features of the Warp configuration: - Instant access to the project backlog and live cloud BFF logs on disk. - Integration with identity provider tunnels and the running frontend client. - Integrated Cosmos instance to step through and verify UI components individually. - Portless benefits: - Eliminates the cognitive load of memorizing which feature is bound to which local port number. - Automatically routes separate Git worktree environments to distinct, recognizable URLs.

---

[01:00:27](https://www.youtube.com/watch?v=C37Wag4cuhU&t=3627s) Managing Concurrent Tab Groups and Asynchronous Agent Work

To illustrate how she manages multi-tasking across the software lifecycle, Marina displays an arrangement of four distinct tab groups running in parallel, each representing a feature at a completely different stage of development and requiring a different level of cognitive oversight. The first tab remains permanently checked out on the development branch (`dev`); she leaves this open to review pull requests from teammates, debug unexpected local setup anomalies, and handle quick bug checks. The second tab group (highlighted in pink) runs Feature 1, which is in the high-touch brainstorming phase; this step demands her full attention as she evaluates architecture choices, accepts decisions, and monitors incoming HTML mockups.

By contrast, the remaining tabs operate asynchronously. Tab group three contains Feature 2, which has advanced to the Architecture Decision Record (ADR) phase and is paused while awaiting peer reviews on GitHub. The final tab group hosts an active sub-agent implementation. Because she stayed deeply involved during the earlier exploration and planning phases, this coding stage needs only minimal oversight:

> “And here, I have been very close to it in the explore and planning. So, now it's just like lower little oversight. It just needs to get done. And this can run like sometimes for half day and sometimes for like a whole day without me watching.”

Once the automated agent runs conclude, she steps back in to review and verify the output.

---

[01:01:48](https://www.youtube.com/watch?v=C37Wag4cuhU&t=3708s) Five Core Takeaways and Closing Remarks

Reflecting on her experience across projects, Marina condenses her talk into five fundamental principles for working effectively with agentic AI:

1. **AI is merely a tool; the human mind provides the magic:** > “AI is just a tool, nothing more. And what makes it magical is your brain combined with it.” She compares software development with AI to painting: handing a palette, paint, and brushes to different people can yield either a crude stick drawing or a masterpiece like Picasso. True mastery requires deliberate engineering practice. 2. **The workflow is the product:** Every completed ticket or generated task serves as an empirical test of whether the underlying engineering workflow and feedback loops are functioning properly. 3. **Developers own all generated code:** Marina warns engineers against deflecting responsibility when automated tools fail, noting that the resulting codebase remains entirely the developer’s responsibility. 4. **Adaptive capability is the defining skill of the future:** Embracing a polymorphic mindset—the capacity to transition roles, learn rapidly, and switch cognitive contexts as the work demands—is critical for modern engineers. 5. **Rigorous verification is non-negotiable:** > “And finally, without verification, Claude produces plausible looking code that doesn't actually work.”

In her final remarks, Marina asks the audience for candid feedback via an onscreen QR code, emphasizing that critique is how she continuously improves. She also shares links to her LinkedIn profile and announces that Kodemaker now offers intensive two-day courses on agentic developer workflows, offering attendees a promotional discount code (`NDCi`) valid for the week of the conference.

## Notable quotes > [02:11](https://www.youtube.com/watch?v=C37Wag4cuhU&t=131s) Value shifts from executing tasks to shaping systems. — Marina Santos Haugen

> [04:53](https://www.youtube.com/watch?v=C37Wag4cuhU&t=293s) It's not about agent, it's about the workflow. — Marina Santos Haugen

> [01:01:48](https://www.youtube.com/watch?v=C37Wag4cuhU&t=3708s) AI is just a tool, nothing more. And what makes it magical is your brain combined with it. — Marina Santos Haugen

> [01:01:48](https://www.youtube.com/watch?v=C37Wag4cuhU&t=3708s) Without verification, Claude produces plausible looking code that doesn't actually work. — Marina Santos Haugen

> [26:27](https://www.youtube.com/watch?v=C37Wag4cuhU&t=1587s) When you have many different agents at the same time, if they come back with the same findings, then you are triangulating data. — Marina Santos Haugen

## Mentioned Marina Santos Haugen, Kodemaker, NTNU School of Entrepreneurship, DNB, McKinsey, Boston Consulting Group (BCG), Procter & Gamble, Claude, Claude Code, Claude Cowork, CLAUDE.md, claude-md-management, Model Context Protocol (MCP), Figma, Miro, Linear, Jira, GitHub, GitHub Issues, Context7, Next.js, Agent Browser, Semgrep, OWASP, Playwright, Notion, Anthropic, AI Engineer, Vue, React, Git, Superpowers, eForm SDK, Slack, 21st.dev, Kali Linux, Docker Desktop, Hydra, John the Ripper, Rahul Garg, Chrome, OpenRouter, Gemini Flash, React Cosmos, Storybook, Nano Banana, Conductor, Warp, Cloudflare Tunnel, Portless, Vercel

## Video description This talk was recorded at NDC AI in Oslo, Norway. #ndcai #ndcconferences #developer #softwaredeveloper

Attend the next NDC conference near you: https://ndcconferences.com https://ndc-ai.com/

Subscribe to our YouTube channel and learn every day: / @NDC

Follow our Social Media!

https://www.facebook.com/ndcconferences https://twitter.com/NDC_Conferences https://www.instagram.com/ndc_conferences/

#ai #aiagents

Over the past year, I’ve worked across three projects diving deep into agentic AI workflows – from building a full CRM in three weeks on my own to collaborating in AI-driven teams. A clear pattern emerged: how much more we can do as developers when tools let us shift roles as the work demands. I call this a Polymorphic Mindset.

In this talk, I’ll share practical agentic AI workflows, relevant research on why this way of working matters, and what happens when you take it further with agent teams working in parallel.

How do we preserve the mental model when AI generates thousands of lines of code in seconds?

Expect concrete examples throughout, set in a retro pixel-art cyberpunk world spanning ocean floors and desert landscapes.

[Source](https://www.youtube.com/watch?v=C37Wag4cuhU)

Reading summary

Marina Santos Haugen argues that software engineers must adopt a 'polymorphic mindset'—treating development workflows as their primary product and moving fluidly across product, design, and engineering roles—because unguided AI code generation amplifies costly upstream errors. Upstream Workflow Design and Error Amplification (4:53) Industry research indicates that enterprise agentic AI success depends on organizational workflows rather than model intelligence alone. McKinsey finds that workflow integration is the primary differentiator, while Boston Consulting Group reports that over 85% of companies remain trapped in rudimentary task delegation and 40% of initiatives collapse due to process friction. Corporate spending reflects this mismatch, allocating roughly 93% of budgets to technological infrastructure and only 7% to people, training, and operating models. Haugen stresses that developers retain full accountability for deployed code, cautioning against the illusion of speed created by raw syntax generation. Upstream misunderstandings cascade exponentially: one bad line of syntax creates a single line of faulty code, but one bad line in an implementation plan yields 10 to 100 bad lines, flawed research creates over 1,000, and an architectural specification error can spawn tens of thousands of defective lines. Haugen illustrates this risk with her own experience generating 8,000 lines of pull requests across backend and frontend repositories before discovering her initial system model was completely misaligned. Prioritizing Modular Skills Over Monolithic Agents (17:27) Drawing on guidance from Anthropic engineers, Haugen asserts that developer leverage comes from constructing discrete skills rather than monolithic autonomous agents. Under this paradigm, foundation models function as commoditizing compute processors, agent clients act as operating systems, and domain-specific skills operate as software applications where proprietary business logic resides. To manage complexity, Haugen implements structured pipelines such as the seven-phase 'feature dev' workflow. This pipeline deploys parallel agents during discovery to triangulate repository findings, enforces a mandatory hard stop requiring human clarification before architecture is selected, and formulates alternative designs with explicit trade-offs. Similarly, four-level architectural planning sessions map capabilities, components, interactions, and contracts. Gating these steps before coding produces a concise Architectural Decision Record (ADR), allowing teams to align mental models early when course corrections remain inexpensive. Expanding Developer Scope Across Functional Roles (14:12) A polymorphic developer leverages Model Context Protocol (MCP) integrations to eliminate sequential, siloed handoffs between product management, UI design, security, and engineering. MCP servers connect agent terminals directly to design platforms like Figma and Miro, issue trackers like Linear and Jira, and documentation scrapers like Context7 for real-time framework updates. Developers can also conduct local containerized penetration testing using Dockerized Kali Linux tools and run continuous Semgrep vulnerability scans directly within their coding loop. This cross-functional reach dramatically accelerates product discovery and UI prototyping. In one CRM project, Haugen used document analysis skills to parse a 56-column, 370-row specification spreadsheet, reconciled missing field parameters against an external GitHub SDK repository, and generated a functioning interactive web prototype. This allowed product managers to immediately validate dynamic form groupings and dropdown behaviors, replacing days of manual requirements clarification. Multi-Model Verification and Isolated Execution (51:24) Anthropic's official guidance warns that unverified agent sessions frequently generate plausible-looking code that fails in execution. To counteract this, Haugen isolates code authoring from evaluation by enforcing a strict separation of concerns: code-writing agents never review their own output, and completion requires passing automated test suites, type-checking, and linting. Haugen's verification stack incorporates multi-model evaluation, such as using Google's Gemini Flash via OpenRouter as an independent judge to audit visual designs against structured rubrics, alongside headless Playwright browser tests. In high-velocity delivery cycles, an 'autonomous flow' pipeline runs six local code-review agents, uses automated bots on GitHub pull requests, and executes a 'commit dance' skill to cluster micro-commits into readable git histories. To sustain parallel workstreams without port collisions or context pollution, Haugen isolates concurrent features using Warp terminal presets, Git worktrees, and Portless routing. Haugen concludes that artificial intelligence functions as a force multiplier whose value is dictated by the engineer's domain discipline and workflow design. While autonomous agents enable small teams to operate across the entire software development lifecycle, realizing sustainable gains requires strict verification gates and constant vigilance against unreviewed code generation.

Source quotes

[2:11] Marina Santos Haugen: Value shifts from executing tasks to shaping systems. [4:53] Marina Santos Haugen: It's not about agent, it's about the workflow. [61:48] Marina Santos Haugen: AI is just a tool, nothing more. And what makes it magical is your brain combined with it. [61:48] Marina Santos Haugen: Without verification, Claude produces plausible looking code that doesn't actually work. [26:27] Marina Santos Haugen: When you have many different agents at the same time, if they come back with the same findings, then you are triangulating data.

Original transcript

[0:06] So, hello everyone. It's a true pleasure [0:09] being here today. My name is Marina [0:12] Santos Haugen, and I'm going to talk [0:15] about a polymorphic mindset. [0:18] So, first a little bit about me. So, I [0:20] am a full stack software engineer, a [0:22] consultant from Kodemaker. [0:25] And uh [0:27] I have a background from industrial [0:28] economics and technology management, [0:30] where I focused on computer science and [0:32] AI. [0:33] And I also went to NTNU School of [0:35] Entrepreneurship. [0:37] And uh before I became a consultant, I [0:40] worked 7 years in DNB, where I worked [0:42] from everything from innovation, AB [0:45] tests, to software engineer in the open [0:49] banking, working with DNB's API [0:51] platform, and the online bank. So, as [0:54] you see, I haven't had like an atypical [0:57] career, because I actually went from [1:00] business development, [1:02] and then became an experiment manager, [1:05] and then later I reskilled into a [1:07] software engineer. [1:09] So, you can say that [1:11] I'm very polymorphic. [1:13] I like a little bit of everything. [1:16] And uh over the past year and a half, [1:20] I've been working across three different [1:23] projects, diving deep into Aigentic AI [1:27] and workflows. [1:29] And uh [1:30] what I see is that a very little team [1:32] can get so much more done, because this [1:35] technology it's moving so fast, and it [1:37] has so much power, that they usually say [1:41] that [1:42] AI won't replace humans, it will give [1:45] them superpowers. [1:47] And this is the promise, and then this [1:50] is the reality. Spotted in the wild, the [1:53] Aigentic developer. [1:55] So, this is uh [1:57] uh me, a habitat, a romantic trip to [1:59] France [2:01] uh observed babysitting her agents [2:03] and uh with a laptop never fully closed. [2:07] So, I feel very sorry for my husband on [2:09] this romantic trip. [2:11] But, I can't help it. I get very excited [2:13] about this [2:14] because uh AI gives us the ability to [2:17] shift shape when the context demands it. [2:20] So, I call this uh polymorphic mindset [2:23] uh because polymorphic comes from the [2:26] word polymorphism, which means many [2:28] forms. [2:30] And it basically is that one thing can [2:32] appear in many ways. And this word is [2:35] often used in biology to describe [2:37] variants of uh the same species. And [2:40] then also, as we know, in programming. [2:43] So, we have a one animal contract, but [2:45] then the dog and the wolf is implemented [2:47] differently. So, we have the same [2:49] interface, but different behavior. [2:52] And I'm maybe more polymorphic than most [2:56] because one day I am a uh developer in [3:00] the flow state with three screens, and [3:02] the next day I am at the masquerade ball [3:05] in Versailles. [3:06] So, you can think of it like a game uh [3:10] or a game character. I'm the same [3:12] person, but then I can uh switch uh with [3:16] different abilities by taking on a cape [3:18] or a hat or something. Yeah. [3:22] And usually in uh product development we [3:25] have these three roles. We have the [3:27] product manager, the developer, and then [3:30] the designer. [3:31] So, uh and usually, if we look into the [3:34] roles, the uh product manager uh sets [3:37] direction, prioritizes the backlog, [3:40] makes sure that all the stakeholders are [3:43] aligned, and also that we're building [3:45] something with impact. [3:47] And then we have the developer who [3:49] builds securely, tests, and refactors. [3:53] And then this designer who thinks about [3:55] UI and user experience and also gathers [3:59] insights with quantitative data, [4:02] maps out the user journey, and captures [4:05] the user voice. [4:07] So and I have had responsibility across [4:10] these roles, and now I'm going to show [4:11] you during this presentation how we as [4:14] developer now can kind of put on [4:16] different hats and do [4:18] more than what we have traditionally [4:21] done. And I think cross-functional [4:25] collaboration is key to success. So I'm [4:28] not saying this is an argument for less [4:31] cross-functional [4:33] collaboration. It's just as that these [4:36] agentic AI makes um [4:39] teamwork less sequential and less [4:42] role-based and more [4:44] uh collective. So value shifts from [4:47] executing tasks to shaping systems. [4:53] And uh this is a quote from McKinsey's [4:57] report, 1 year of agentic AI, where they [5:00] say AI is not my It's not about agent, [5:03] it's about the workflow. [5:05] And here this study from BCG says that [5:10] over 85% [5:12] they are still stuck in this task info [5:16] um assistance delegation step. And [5:19] that's like before you have this [5:21] workflow reinvention where you get [5:23] really the organizational value. [5:27] And then [5:28] we also see here from this report that [5:31] over 40% of agentic projects they fail, [5:35] and this is not due to the technology, [5:37] it's due to the process. [5:40] And then here we also see that 76% of [5:44] leaders [5:45] they actually see now agentic AI as [5:48] co-worker and not a tool. So there's [5:50] like huge shifts going on here. [5:53] And [5:55] if we look into some more findings, [5:57] this report from P&G says that they [6:01] found that AI actually broke down the [6:03] silos between different teams. And that [6:06] the AI equipped cross-functional teams, [6:09] they produced three times more [6:12] breakthrough than the others. And also [6:15] that the [6:16] AI removed the functional barriers [6:18] between the R&D and the commercial [6:21] because they could suddenly talk the [6:22] same [6:23] language in a way. [6:26] And but this is not given because [6:28] another report says that individual AI [6:32] does not equal team value and that here [6:35] we see that 93% of AI budget goes to the [6:39] technology, but only around 7% goes to [6:42] actually the people. [6:43] So and without deliberate workflow [6:46] design, [6:47] individual AI use can actually erode [6:50] team work or how a team works. And I've [6:54] actually experienced this in my last [6:56] project because suddenly like we were [6:59] talking and discussing less together [7:01] because you were sparring with an AI. So [7:04] suddenly we didn't discuss thing in our [7:05] team. So we need to be very very aware [7:08] that these this technology is actually [7:10] changing how we work. [7:13] And then finally that transformation [7:15] requires redesign. So organizations that [7:18] redesign workflow, not just deploys new [7:21] tools, [7:22] they actually achieve [7:25] transformation in [7:28] And another thing that we need to [7:29] transform is actually our definition of [7:33] an engineer and definition of coding. [7:37] So [7:38] uh [7:39] we need to remember that AI it's just a [7:41] tool, and you are responsible for the [7:44] output, and you own the code that is [7:48] generated. So, when something fails, [7:50] it's easy to blame like, "Oh, the AI did [7:52] that so wrong." [7:53] But, I would argue that that's your [7:55] responsibility, and that if it produces [7:58] something shitty, then it's actually [7:59] your fault, because maybe you haven't [8:02] guided it or had the good a good [8:04] workflow. [8:07] And now, with the [8:10] AI, it's very easy, as we said, to feel [8:13] like you have superpowers. It's so easy [8:15] to generate a lot of code, and it's just [8:18] like we'll click, and then woo, you are [8:20] done. [8:22] But, I would say that is the seduction. [8:25] That you think like, "Oh, look how much [8:27] code I produced, or how much progress [8:30] I've made." But, then the code is very [8:33] shitty. So, it's very important to [8:36] remember or make sure to focus where we [8:40] as humans can give the most value. So, [8:44] now it's not about like the syntax and [8:46] every line of code anymore. Like, one [8:48] bad line of code equals one bad line of [8:51] code. [8:52] But, then one bad line of plan equals 10 [8:55] to 100 lines [8:57] of bad code. [8:59] And then one bad line of research equals [9:01] over 1,000 lines of bad [9:05] code. [9:06] And then one bad bad line of [9:07] specification, then you have kind of [9:09] like understood the wrong [9:12] you have the wrong problem. This is [9:13] about you misunderstanding the system. [9:15] And here you have like [9:17] 10,000s of bad line of code. [9:20] And then in the bottom, we have the core [9:21] infrastructure. That is like, if you [9:23] have one bad line of [9:25] my instruction in the cloud and there, [9:27] which is loaded on every [9:29] session, [9:31] then [9:32] you have like hundreds of thousands of [9:34] bad line of code. [9:35] And this actually happened to me [9:36] recently in a project where I had I was [9:41] quite new to the project and I had [9:43] misunderstood the system. So I had bad [9:45] research and then suddenly I was stuck [9:48] in this implementation trap. [9:51] I would say I got like two huge PRs, one [9:55] for back end and front end was 8,000 [9:57] lines of code and I was stuck here in [9:59] like a refactoring game. [10:01] And [clears throat] this is a very [10:02] expensive way to find out that you've [10:05] done something wrong because you have so [10:07] much code and it's very hard to see [10:10] and find out what you have done wrong, [10:12] right? [10:14] So [10:18] it's very important to think more about [10:20] the workflow now as the product. So [10:24] every time you get a task, you can think [10:26] of it as just a test that you are your [10:28] workflow [10:30] works and that it's good. [10:33] And [10:35] I [10:36] have called this like autonomy of a [10:39] workflow. [10:40] So I usually follow this process where I [10:42] go through like an exploration phase, a [10:45] planning phase, code and verify. And [10:47] this is not a linear [10:49] loop. I can jump a little bit back here [10:52] and now. [10:53] But this then builds on some blocks that [10:56] power it. [10:57] So we have the configuration which is [11:01] like my personal [11:03] adjustments for my optimal flow. And my [11:06] optimal flow might be different from [11:08] your optimal flow, right? Because we [11:10] have different needs. [11:12] And then we have the skills and the [11:14] plugins and [11:16] I think most of you maybe are familiar [11:18] with skills, but basically that that's [11:20] just a recipe for a task written in an [11:22] markdown file. [11:24] And a plugin just bundles the skills so [11:27] it's easy to kind of share and install. [11:30] And it can bundle a hooks and MCPs in [11:32] the in the plugin. [11:34] Uh so, but these then you have kind of [11:36] the ready-made skills that comes uh with [11:39] Claude or wherever or from marketplaces [11:41] or the ones you make yourself. [11:44] And then uh the MCP, which stands for [11:46] model context protocol, that is just a [11:49] USB-C port for all the AI uh [11:51] applications so that your agents can [11:54] talk to your external uh tools that you [11:58] use. [11:59] So, now we will go through each of these [12:01] parts and I will show you examples of uh [12:04] how I work. [12:06] So, if we jump into configuration first, [12:08] so the first thing I do uh is to kind of [12:11] like avoid death by prompt deny uh or [12:16] allow deny prompts. So, do housekeeping [12:19] on your permissions. You can check them [12:21] with {slash} permissions. [12:23] Uh or you can also use use me to have [12:26] auto mode on so I don't need to [12:28] uh [12:30] accept everything all the time. [12:32] And then uh I like to have something [12:35] called insight boxes, which is the ones [12:37] you see here with a star, and these kind [12:39] of like tells me [12:41] uh the patterns and the reasoning for [12:43] choices that uh the agent does. And it's [12:46] very practical if you're new to a code [12:47] base and you need to quickly get into [12:50] things. And that you can enable by [12:52] {slash} config and then you go to output [12:54] style and then explanatory. [12:57] And then uh keep Claude MD the core [13:01] infrastructure up to date at uh every [13:03] time. Uh so, here there's a plugin [13:06] called Claude MDM management. [13:08] And um within that one there is a skill [13:11] called Claude MDM improver. So, if you [13:13] trigger that one, you will kind of get [13:15] like a score grading on your Claude MDM [13:18] file and it will suggest things that you [13:20] can improve. [13:21] And there's also another command [13:23] actually within this uh [13:25] uh uh, plugin called revise Claude MDM. [13:28] So, when you're sitting in a session and [13:30] you learn something new or it does [13:32] something wrong, you can trigger this [13:34] and it will actually catch the learning [13:36] from that specific session. [13:39] And then, finally, just managing context [13:43] so that you have good quality of code [13:45] because if you, uh, code and you have [13:48] very little context left, then the [13:50] output of the code gets worse. So, I use [13:53] often like compact and clear to make [13:55] sure that I have a good, uh, window. And [13:57] also, you can configure a status line, [14:00] uh, [14:01] as you want, but I have the working [14:04] direction, my directory, uh, visible and [14:06] also a context warning telling me how [14:08] much I have left. [14:12] Okay, so if we move over to MCP servers. [14:16] So, these are some examples of the MCP [14:18] servers that I use. [14:19] Uh, so within design, it, uh, often [14:22] depends about, uh, what client or the [14:25] organization, the tools that your [14:26] designers use, but you can have, uh, [14:29] a plugin to Figma to create and get [14:31] design, uh, to Miro to draw and read [14:34] whiteboards and do ideation. [14:37] And I will talk about 21st day later. [14:40] Then in issue tracking, I connect with [14:42] linear and Jira and GitHub issues. And [14:45] it's super nice to create when I find [14:47] bugs and automate, uh, how it creates, [14:51] uh, the issues. And they I can attach [14:54] pictures and a lot of details, so I [14:56] think it's very nice. [14:59] And then for documentation, uh, I use [15:01] context 7 and notion. I will show an [15:03] example of that, too. And then within [15:05] secure night testing and security, [15:08] Semgrep MCP server for, uh, security [15:11] analysis. And then Playwright to [15:13] automate browser, uh, testing [15:16] and demo recording. So, I'll also show [15:18] that. And you can check what MCP servers [15:21] you have with {slash} MCP. [15:23] So, uh, an example of Context 7, because [15:26] that gives you fresh documentation. [15:29] Because as we know, the models [15:31] that these LLMs use, they have a cut [15:34] cut-off data on the training data. So, [15:37] it's outdated. So, it's very nice when [15:39] you for instance need to update [15:40] dependencies and look for like breaking [15:42] changes or patch updates and so on. Uh [15:45] you see here the landing page of Context [15:47] 7, where you can see that Next.js, they [15:50] have access to the recently updated 9 [15:53] hours ago uh code [15:56] and documentation. So, for instance, [15:58] here you see an example how I used it to [15:59] research uh which browsers I can use uh [16:03] for more authentic [16:06] uh optimized browsers. So, here I ended [16:09] up using Agent Browser. [16:11] Um yep. [16:15] And here you see an example of how I can [16:17] use uh Miro and Notion. So, for [16:20] instance, I got this uh huge uh decision [16:23] tree uh on a project, and it was very [16:27] hard to actually figure out what was the [16:29] happy path and map out kind of in code, [16:32] what does this mean? [16:34] Uh so, then I could actually read get [16:36] the Claude to read this and map out [16:39] everything in text, so that I had [16:40] actually the happy flow and all the [16:43] decisions. So, it's very nice to um [16:47] do research basically. And this is very [16:50] easy to share later with non-technical [16:52] people or a PM. [16:56] And here you see Semgrep, uh the MCP [16:59] server. So, uh [17:01] this will then work in collaboration [17:03] with Claude Code, so that the agent [17:05] edits code, and then the output gets [17:08] scanned by OWASP 10 [17:10] uh [17:11] for vulnerabilities, and then Claude [17:14] will kind kind just on that uh [17:17] the findings. So, this is very nice that [17:20] it just like runs and you get more [17:22] secure code. [17:26] And uh [17:27] if we move over to skills and plugins, [17:30] so in uh [17:32] 2025, in December I think, um Anthropic [17:37] had two of their employees in uh [17:41] uh AI engineer, a conference and YouTube [17:43] channel, and they was very clear, like [17:46] don't build agents, build skills [17:48] instead. [17:50] And uh they made this model [17:53] to kind of explain it, so that uh if you [17:56] can compare the models as the [17:58] processors, and there's like little [18:01] value uh or more value to kind of take [18:05] out of the different models. They're [18:07] getting very good, and like even the [18:09] small models are catching up with the [18:10] big models. [18:12] Uh [18:13] but then outside of that again, you have [18:15] kind of the agents, the operating [18:17] systems, [18:18] uh like for instance, um Claude agent, [18:21] and they will have kind of like [18:23] different way to ask you questions, [18:25] different way, like the client around [18:27] it. Uh so, that would also make some [18:29] difference, but still like not that [18:31] much. And then outside of that again, is [18:34] kind of the skills, and you can compare [18:36] that as all the applications. So, if you [18:39] think about applications today, they are [18:41] so different, and this is kind of like [18:43] where we can really both get the value, [18:46] but also kind of like get the domain [18:48] expertise, and all the differences. [18:53] So, uh for instance, to make this [18:56] presentation, I have made this skill [18:58] called pixel theme, because I have a [19:00] thing for pixel aesthetics. Uh so, [19:05] then I can just trigger this skill, and [19:07] basically, I can generate every [19:09] landscape or illustration that I want [19:12] within that theme. So, kind of like [19:14] suddenly if I want to have like [19:16] something underwater, it's super easy [19:18] for me. Uh [19:20] and it took some time before I made this [19:21] skill. So, I used a lot of time to kind [19:23] of like struggle with the ChatGPT [19:26] picture generation and I was never happy [19:29] because it like didn't follow the color [19:31] theme and it did not look like the same [19:33] presentation at all. [19:35] But then with this pixel theme skill, [19:37] it's super easy. [19:39] And [19:40] it takes time. [19:42] Again, like think of it as a [19:44] the workflow as a product instead. So, [19:47] it took like at least 15 iterations [19:51] before I was any happy or it actually [19:53] started to produce good [19:56] results. [19:59] And then [20:01] so this [20:02] kind of like is an overview of the skill [20:04] ecosystem. [20:06] So, you have kind of the skills that [20:07] come bundled within uh your agent. For [20:11] instance, in in Claude that I use, [20:13] uh you have for instance /batch, which [20:16] it it's very nice if you for instance [20:17] need to migrate from view to react. Uh [20:21] then you can kind of like batch and do [20:23] several changes at the same time on [20:25] different UI components. [20:28] Uh [20:28] and then with one instruction. [20:30] And then debug for debugging, simplify [20:33] for to make code more [20:35] elegant and simple. [20:37] Uh and then loop if you need to kind of [20:40] verify something several times before it [20:42] stops. [20:43] Then you have the marketplaces and here [20:46] Anthropic is very [20:48] uh cautious and says like don't trust [20:50] any third-party [20:51] uh [20:52] skills. And I [20:54] don't do that. I don't copy that much [20:57] skills from anyone. Just I used the [20:59] official ones from Claude and then I [21:00] used the [21:02] uh Anthropic's agent skills that they [21:04] have provided through a [21:06] uh [21:07] GitHub uh [21:08] And then I can kind of like browse and [21:10] get inspiration from other skills, but I [21:12] never like download them. I just make [21:14] them myself because it's so easy. You [21:16] can just read and then you can make [21:18] whatever skill you want, basically. [21:20] So, these are different skills that I [21:22] usually use. [21:24] Uh so, I will go through uh many of them [21:26] now. And then of course, you have the [21:27] custom ones that you can create your [21:30] own. [21:31] Uh yeah. [21:34] So, uh so [21:36] this is for instance superpowers, [21:38] which is kind of like a whole flow with [21:40] 14 different skills. So, you have skills [21:43] within planning, uh brain now [21:46] implementations, scaling, and quality. [21:48] So, in planning for instance, uh I'll [21:51] show you how brainstorm work, but that [21:53] basically basically creates a spec. [21:56] Uh and it goes through like um [21:59] brainstorming session that it asks you [22:01] question, but what's nice about this is [22:03] that it's it uh [22:05] illustrates it in uh HTML page. And this [22:08] is very nice because with AI agents, it [22:11] can generate a lot of information and [22:13] code, and you can get very tired of [22:15] reading everything. So, then using this [22:17] skill, then you can visualize it. So, [22:19] it's very nice. [22:20] And then writing plans to kind of like [22:21] break down the task into testable steps [22:24] uh when you're implementing. [22:26] And then uh implementation, then I often [22:28] use test-driven development and [22:30] systematic debugging. [22:32] In scaling, you have for instance [22:34] working with the sub agent-driven [22:35] development so that it's being solved [22:38] different agents that get their own [22:39] context window. [22:41] And then uh you using work trees. [22:45] Uh yeah. And then in quality, uh you [22:47] have this verification before [22:48] completion, which is very nice because [22:51] instead of just [22:52] uh AI uh an agent will often kind of [22:55] like say, "Yeah, I'm done." [22:56] in a way because it just wants to finish [22:58] the session. But then if you trigger [23:00] this skill, it has to actually verify, [23:02] okay, like run all the test, all the [23:04] linting, type check, and actually verify [23:06] that you are actually done with the [23:09] acceptance criteria. [23:10] And then this, if you are requesting [23:13] code review, you want uh [23:17] to get a review on something you've [23:18] done, or if you have received some [23:20] comments on your PR that you want to [23:23] help brainstorm with an agent, [23:26] then you can use the receiving code [23:27] review. [23:28] So, this is very nice. [23:30] Uh and then here you see, for instance, [23:32] how brainstorming works in practice. So, [23:36] it will open then this HTML page, and [23:39] you will get asked questions, and [23:41] sometimes it gives you several [23:43] options, like A and B, and you can click [23:45] it in there, or you can answer and [23:46] iterate more in the terminal. [23:48] Uh so, this is very nice, because then [23:50] you kind of like visualize and see, oh, [23:52] okay, no, I don't want this like [23:54] clickable [23:55] filtering, I want these buttons for [23:57] because it's not that many filters that [23:59] I need, and so on. [24:01] So, it's very nice. [24:04] And then you have the front-end design [24:06] skill, because with AI, it tends to kind [24:10] of like make everything look like [24:12] AI-produced stuff. It's like very sloppy [24:14] and just one design. But if you use this [24:18] skill, front-end design, it will [24:19] actually try to understand what are you [24:22] building and what is customer need, and [24:24] like try to actually [24:26] figure out a design profile that works [24:30] with what you are building. [24:33] Uh so, [24:35] for instance, here you see uh two fault [24:38] sessions where I will give the same [24:40] task, but different inputs, and it [24:43] generates two completely different [24:45] processes. [24:46] So, for instance, here this, I would say [24:47] like brute force, just like build user [24:50] story one, create topic. [24:52] And then it goes ahead and it does like [24:53] a lot of different things and writes [24:55] stuff, and then it says, "Okay, I'm [24:57] done." [24:58] And then the next one, I say like build [25:01] U Store one, start with brainstorming [25:03] for an aesthetic direction, and then a [25:05] front-end design to implement it. So, [25:07] then you will see that it starts to [25:09] brainstorm. Obviously, it opens like a [25:11] browser. It shows me kind of like three [25:14] alternatives. So, this was for uh [25:17] paramedic learning platform. [25:19] Uh so, then I was like, "Okay, let's go [25:21] for the clinical reference like a [25:24] medical publishing platform and what [25:26] font and so on." [25:27] And then [25:28] uh I said like, "Okay, now we have the [25:31] aesthetic. So, I would like you to save [25:33] this into uh [25:35] uh [25:35] design theme docs so that I can use this [25:39] theme again and again across all the [25:42] app." And then it would go ahead and use [25:45] that uh documentation to actually [25:47] implement the design [25:49] with the front-end design skill. [25:52] So, then here you see the result. So, [25:54] two different processes gives two uh [25:57] totally different uh products. So, here [26:00] you see this very very boring Next.js uh [26:04] uh front page just like black and white, [26:06] super boring. And then this one has like [26:10] this uh journal fee- feel, and it has [26:13] like this paper color, a nicer font. [26:15] This was for like ambulance personnel. [26:18] So, it has like shows like uh red and [26:20] white color. [26:22] Uh so much better. [26:27] And then uh we have covered superpowers, [26:29] which is like a toolkit, but then you [26:32] also have something called feature dev, [26:34] which is a seven-phase [26:36] uh [26:37] uh [26:38] pipeline in a way. [26:40] And um [26:42] it will then go through seven steps. It [26:44] start with discovery, which where it [26:47] kind of like um captures the ask and [26:49] makes a to-do list, and then it goes [26:51] ahead and starts the exploring phase, [26:54] where it will actually spin off two to [26:56] three different agents. And that's very [26:58] good because when you have many [26:59] different agents at the same time, if [27:02] they come back with the same findings, [27:04] then you are triangulating [27:06] data. So, you can be very sure that it's [27:09] a good idea or it's a nice bug they [27:12] found or whatever. [27:14] And then step three, this is kind of [27:16] like the first hard stop where it will [27:18] not continue without your input. [27:21] So, this is kind of like the [27:22] clarification phase where it will ask [27:24] more questions. [27:26] And then it goes over to architecture. [27:28] And the good thing here is that it will [27:30] not just suggest one architecture. It [27:33] will suggest up to three different [27:35] architectures. So, then you can actually [27:37] evaluate pros and cons of each of them. [27:40] And then [27:41] implementation, and then you have given [27:44] your input. So, now it's like, well, [27:46] let loose. You can go because I have [27:48] been with you the whole way, and now I [27:51] know actually my mental model is the [27:53] same as yours. You can go ahead. [27:55] And then we are on the review phase. [27:58] Again, it spins off three different [28:00] agents and looks for simplicity, [28:02] correctness, and [28:04] conventions in the repo. And then [28:06] finally, the wrap up phase. [28:09] So, it's just nice to know. So, I would [28:11] encourage you to try the different [28:13] processes, both superpowers, and then [28:15] compare it. How does [28:17] it feel using feature dev? And then find [28:19] the things that you like. [28:23] And here, for instance, you might think [28:26] these are similar. These are two skills [28:29] to do code review. And my colleague here [28:33] the other day, he was super surprised [28:34] because suddenly the the bot just [28:37] commented on the PR without him knowing. [28:39] But right, this is actually uh [28:42] described in the skill that it will do [28:44] that. Output post a comment on the PR. [28:47] And it will only do so if [28:50] uh [28:50] the scoring is over 80%. So, it's quite [28:53] strict. [28:54] Uh and there's no customization in here. [28:57] And I often use this if uh it's a [29:00] a PR that is already on GitHub that I [29:02] need to look into. [29:05] And it will also spin off different [29:07] agents in the review. So, this is like [29:09] one thing. Uh but this one I use very [29:11] often when I'm working uh [29:14] locally and finishing up a feature. [29:17] That's like the final step that I do. [29:18] Then I trigger this. [29:20] And it actually writes a summary in the [29:22] terminal. [29:24] And it has a lot of customization. I can [29:27] check all of these things, but I can [29:28] also say, "Okay, I would just want you [29:30] to look into the comments. Like, is [29:31] there [29:32] any comments that we need to delete or [29:34] uh something like that?" [29:36] And it will also use different agents. [29:42] And then there's also a documentation [29:44] skills. [29:45] Uh and I would say this is very commonly [29:48] used by business people and product [29:50] management. But I would argue that this [29:52] is also very nice for uh developers. So, [29:56] this skill is also available in the [29:58] uh Kwork um [30:01] Cloud Kwork, the desktop app. [30:03] So, it has many different uh skills that [30:06] you can use to read [30:08] uh and analyze different document types. [30:11] Then it has also many things you can do [30:13] within the design. And you would think [30:16] that brand guidelines helps you create [30:19] your own uh brand guideline for your [30:21] app, but it's not. It's actually [30:24] creating a entropic-looking design. [30:28] Uh so, it's But it's nice if you need [30:29] want to kind of like uh make an [30:31] animation terminal or uh something like [30:34] that. [30:35] But then you have this theme factory, [30:37] will which actually will help you um [30:40] It comes with 10 ready-made themes. [30:43] And this is the front-end design bundled [30:45] in this plugin, too, that we just [30:46] covered. [30:48] And this is of use for communication, [30:50] like if you need to post something on [30:52] Slack and so on. [30:53] And this is also interesting. I use the [30:56] web artifacts a lot to kind of get up [30:59] mocks of design when I develop stuff. [31:03] And also the skill creator, which I will [31:07] tell you about later. [31:09] So, just to show you an example with [31:12] this skill in action. So, here [31:15] in a project, I got this as [31:17] documentation. And it was an Excel with [31:20] 56 columns and over 370 rows. And my [31:24] task was to go in and figure out, okay, [31:28] row number 16 and 29, and map out [31:33] every uh [31:34] field that had an M for mandatory and CM [31:37] for conditional mandatory and then [31:40] optional. And I had to kind of like make [31:42] a wizard based on this with the right [31:45] questions and the options. But, if it [31:48] said code, then it was an invalid that I [31:51] did not find in this documentation. So, [31:53] I had to go into GitHub and the [31:56] eForm SDK to find it. So, this would [31:59] take like so much time without AI. But [32:03] then, with the Doc Skills, the Doc Skill [32:05] could just analyze and prompt this out [32:08] to me. [32:09] And then, it doesn't stop there, because [32:11] this is also the good thing with AI. [32:13] It's so easy to visualize and produce [32:16] things. So, I could actually go ahead [32:18] and make a prototype that I could give [32:20] to deploy and give to my PM so that he [32:24] could click around and play and learn [32:27] uh kind of like, okay, [32:29] eForm 16, what are mandatory fields? And [32:32] then, if it said code, then he could [32:34] actually go in and he could open and see [32:37] what the options would be and then [32:38] decide, okay, this should go into the [32:40] sketch and not in a way. And also it [32:43] could suggest like, okay, how should we [32:45] group the different information [32:47] in a So, it's like a super nice for [32:49] research [32:51] and to kind of nail a better product, I [32:53] would say. [32:55] So, and then there's another skill [32:58] called security review, [33:00] uh [33:01] which you can trigger explicitly and it [33:03] will do uh a a security analysis. And [33:06] you can also set this up to run in your [33:09] CI if you want. [33:11] Uh but here you see just an example of [33:13] how it can run. So, now I'm actually [33:16] scanning many files. You see 12 files [33:18] and it actually tells me kind of like, [33:19] okay, findings, [33:21] a high severity, medium, low, and then [33:24] give me some ideas of things that I can [33:26] improve. [33:30] And you can also let Claude find your [33:34] uh automation, like things you can [33:37] improve. So, with this skill, the Claude [33:41] automation recommender, [33:42] it will actually then suggest like which [33:45] hooks I should set up. So, for instance, [33:47] here I did this after it suggested it, [33:50] but it said like you can set up a [33:52] pre-tool use where it blocks that [33:55] I Claude can go in and change things in [33:58] the dot env file. And it can suggest [34:00] skills, what sub-agents I can set up, [34:02] MCP servers that I can [34:05] connect. [34:07] And also quick wins. For instance, if I [34:10] need some housekeeping on my [34:11] permissions, it can actually scan [34:14] all my conversations and see, okay, but [34:16] you usually accept this all the time, so [34:19] why not just like make a rule for it? [34:23] And then we have all the custom skills [34:26] that you can create. And here it's your [34:28] imagination that is the limit, really. [34:30] So, here you see an example of different [34:32] skills that I've set up. So I've made [34:35] for instance test implementation skill. [34:37] So this will have access to some test [34:40] users. It will have an overview of [34:42] my app and uh [34:44] the routes that it has. So then I can [34:46] just paste a linear issue or a GitHub PR [34:51] and then it will actually go ahead and [34:52] test that the acceptance criteria are [34:54] met. And I can combine this with a demo [34:57] demo recorder. So it will record a GIF [35:00] or or a video and then [35:03] actually post a Slack message that [35:05] describes what I just implemented. [35:08] Um [35:09] and then a pedagogical PR review I will [35:12] show you in a second. This one I will [35:13] also show you in a second. This one This [35:15] one I have talked about. Yeah, and this [35:17] one for instance [35:18] um I've made a skill to kind of make it [35:21] easier to do dependency updates so that [35:25] it will actually go ahead and call the [35:27] Contact 7 MCP server to fetch the the [35:31] updated documentation. [35:35] So and I said that uh [35:38] uh [35:41] you can create your own skills, but it's [35:43] important to create them correctly so [35:45] that they work. [35:47] Uh so you can actually use the skill [35:49] creator if you want to create a skill. [35:52] And uh that will help you kind of like [35:55] get the right structure of it, the right [35:57] uh uh variables [35:59] and uh kind of suggest what the [36:02] description trigger should be. [36:04] Uh but then you can also check it with [36:06] the writing skills and it will then [36:09] uh kind of like test it and give you [36:11] feedback if you should improve anything. [36:13] So it's like kind of like a quality [36:15] check of your skill. [36:17] So uh just to show you some example of [36:20] the skills that I created. So this one [36:23] was when I worked with a CRM system. [36:26] And I was getting annoyed that the AI [36:29] was suggesting design and UI components [36:32] that did not follow our design team. So [36:34] then I said like, first step, let [36:36] redesign the theme. And then second [36:38] step, uh I wanted to get [36:41] um inspiration from different sources. [36:44] So I wanted to use 21st Dev, and this is [36:46] an open community platform where uh both [36:50] developers and uh [36:52] designers can [36:53] share their [36:55] um design components. [36:57] And then uh search in parallel. And [37:00] because 21st Dev is an open platform, [37:03] whoever can add things there, it's not [37:06] that secure, right? So then step three [37:08] was [37:09] read the output from this MCP server and [37:12] check that it is secure. So it would [37:15] then go ahead and scan it for React uh [37:18] top 10 vulnerabilities. [37:20] And then step four, it would synthesize [37:23] one to four alternatives. And this was a [37:25] project where where I didn't have a [37:26] designer, right? So I I had to kind of [37:28] be the designer myself. [37:31] Uh and then it would save it to a [37:32] research document. [37:34] So here you see that how I can browse, [37:36] and I like this uh rainbow thingy, and [37:39] this is actually after a conversation [37:40] and it triggers up and shows me an empty [37:43] state uh component, and I can see the [37:45] different ones. I like this one, and [37:47] then I could like chat a little bit and [37:49] say, okay, I want this and that changed. [37:51] And then I could go ahead and copy the [37:53] code or [37:54] uh just look into it or yeah. [37:59] And the this is the pedagogical PR [38:02] review skill. [38:04] And with Agentic AI, it can sometimes [38:06] produce very big PRs. [38:09] And uh I was getting a little bit [38:11] overwhelmed about that, because it's [38:13] very like hard if you're reviewing [38:14] someone else's PR and you don't have the [38:16] same mental model. [38:18] Uh so then I created this skill that it [38:20] would And this was also a project where [38:22] I was quite new to the code base. So [38:24] then having this skill, it would [38:26] actually educate me at the same time for [38:28] every PR I learned more and more. [38:31] So uh [38:32] here you see how I trigger it with a [38:35] GitHub number. And as you see here, this [38:37] is huge. It had 90 files. It deleted [38:41] 41,000 lines of code. So this was [38:43] actually a good day [38:45] at work. Uh but it was delivering four [38:47] different tickets. So it would start off [38:50] and give me kind of like an overview [38:51] orientation of okay, what is this about? [38:55] And sometimes it draws up like uh ASCII [38:57] diagrams for me to understand. And then [39:00] it suggests, okay, I suggest that we go [39:01] through this in 13 steps and group it [39:04] like this. [39:06] And then it would go ahead and start [39:08] like going through [39:09] uh sometimes it's like per file, [39:11] sometimes if it's very big, it's like [39:13] per domain or part. So then it goes and [39:16] explains me a lot in the code [39:19] uh things that has been done and it [39:21] catches improvements on the way. [39:23] Uh and adds it to a to-do list on the [39:25] bottom. And then [39:28] uh [39:28] after some time, after all the 13 steps, [39:31] you see that I usually dig into each of [39:34] the findings and be like, okay, now [39:36] let's verify. Is are these findings [39:38] actually good findings and should we [39:41] leave a comment in the PR or not? [39:44] Yeah. [39:46] And uh [39:47] this is another skill that I created [39:49] because I'm not a security uh [39:52] engineer, right? But it's so cool that [39:54] we now can actually do things uh that [39:58] previously we had to kind of like rent [40:02] uh someone in to have a pen penetration [40:05] test. And I'm not saying it should kind [40:07] of like uh [40:08] uh how do you say it? Erstatte? [40:11] Thank you. But just like it's nice that [40:13] you can do a a small penetration test [40:16] from home in a container Uh [40:19] and like you can find some [40:20] vulnerabilities by yourself. So this was [40:22] also like this one man project that I [40:24] was working on. [40:26] So then I use something called Kali [40:29] which has an MCP server that gives you a [40:34] 11 different tools here. So you see from [40:37] like port scanner to see if every any of [40:40] the ports are exposed. Web vulnerability [40:43] scanner. [40:44] A [40:45] directory brute force, SQL injection [40:47] tester, WordPress scanner. And I was [40:50] like, why do we need this? [40:52] But then [40:54] it used this to kind of generate words [40:56] so that it could try different URLs like [40:58] {slash} admin and see, okay, can I get [41:01] in there? Is it secure? [41:03] And then you see it has some funny names [41:06] like Hydra attack and John crack, [41:08] password cracker. [41:10] So this is very nice. So then I am on my [41:12] machine. I have like a docker desktop [41:15] and then this [41:17] I let it loose and it tries to hack the [41:20] system that I built and gives me [41:23] feedback on vulnerabilities that I [41:26] should handle. [41:28] So this is very nice. But [41:30] the first time I did this [41:32] and I asked Claude like, okay, I want to [41:35] try to use Kali. [41:37] It actually went ahead and found the MCP [41:42] server from a random guy on GitHub first [41:45] and not the official Kali. So be aware. [41:49] Always be aware that [41:51] yeah, it's it can do stuff. So you need [41:53] to follow along. [41:56] Okay, so now over to the workflow. [41:59] So here you see the workflow that I use [42:02] and different things that I do. So the [42:04] first phase is about kind of like [42:06] understanding and research, both design [42:09] but also architecture. So here I use uh [42:12] brainstorming, design first [42:13] collaboration that I will show soon. [42:16] UI inspo that we covered with 21st Dev. [42:19] And also cloud desktop and co-work. And [42:22] this I use to uh for instance, mock [42:24] design or make uh specification. So, [42:27] I'll I'll show you this later. And this [42:29] is like usually design and and uh [42:32] PM work, right? [42:34] So, and then in plan, I scope issues, I [42:37] use writing plans and plan mode. Code, [42:41] then it's uh sub-agent driven, work [42:43] trees, and so on. Verify, yeah, I'll [42:45] cover this, too. [42:47] So, if we look into real example. Uh so, [42:51] this is from uh the CRM system that I [42:54] was building. I got in this issue [42:56] suggestion that can we add a period [42:59] filter to the leads board. [43:01] Right? And here you see that the user [43:03] has attached uh screenshot of where it [43:06] should be. And as we know, never listen [43:09] to solution suggestions from users. [43:12] First, understand the problem and the [43:14] need. [43:15] Cuz here you see that they suggest like, [43:17] "Let's put the filter here." Right? [43:20] So, let's see what the process teaches [43:22] us. So, then uh the first thing I did, [43:25] and this was the my ever first time [43:27] using co-work. I haven't used it a lot, [43:30] but I was very surprised. Because what's [43:33] cool is that you can trigger the [43:34] plugins. And here you see that I get a [43:37] lot of domain expertise. So, I can like [43:40] go into legal and kind of like get help [43:43] uh [43:44] or [43:45] legal competence, finance, data [43:48] scientist, [43:49] engineering, and product management. So, [43:51] then I was curious, okay, let's check [43:52] out this like write spec uh thingy. [43:55] So, now I am putting on the product [43:57] management hat and exploring product [44:00] requirements. [44:02] So, here you see how I then uh [44:05] trigger the screen skill, writing plans, [44:07] give it some context, the GitHub issue, [44:10] and you see that it has access to the [44:12] code base. [44:14] And you see I treat the scale, it starts [44:17] by making a to-do list with the [44:19] different tasks. You see that it [44:21] connects to GitHub. [44:23] And then it starts kind of like [44:25] planning. And after some time it has [44:27] created a product requirements doc where [44:30] it describes the problem, the goals, the [44:33] non-goals, [44:35] user stories, how we should split up, [44:37] edge cases, the requirements, [44:39] prioritized acceptance criteria. [44:42] So this is super nice, right? And of [44:44] course [44:45] um [44:47] I chose a very easy or small example [44:50] just to show you kind of the process. [44:52] This is maybe overkill for a filter, but [44:54] anyways it's just to show you. [44:57] So [44:58] here you see how I then [45:00] scope it. I am moved from explore into [45:02] planning and I scope it in GitHub. And [45:05] here again I'm using the GitHub [45:08] MCP server. You see that it has actually [45:10] created a comment with the different [45:12] issues in the issue. [45:15] And then you can see it reference the [45:17] spec, it gives me like acceptance [45:19] criteria, tasks. So this is very nice [45:22] because when I let loose the agents, [45:24] they need to have all the context, [45:26] right? So then everything is attached to [45:28] the GitHub issue and that it has made [45:31] several issues subtasks. [45:35] So [45:36] after that, we now have the why and the [45:39] what, but we still don't have the how. [45:41] Like how should it look? How should the [45:44] design be? And also how should the [45:46] architecture be? The technical [45:48] decisions. [45:49] So then [45:51] here you see how I use clerk again to [45:53] actually make a mock-up and it has [45:55] access to the code base. So now it has [45:57] made a replica of the read leads board [46:00] and it says, "Okay, so you in our [46:03] company, we use OKRs and we use [46:05] half-year measures. And it just makes [46:08] sense to filter the færdi lane. So, it [46:11] suggested to put the filter inside the [46:14] færdi lane. [46:15] Uh and it has then Now, I can like take [46:17] a screenshot and attach that to the [46:20] GitHub issue. So, again, when I let [46:22] loose the agents, they have the [46:24] screenshots, they have everything in the [46:26] issue. [46:29] Yeah. [46:30] So, now we have the design [46:32] and then the architecture. So, [46:36] uh [46:37] again, with these [46:38] AI agents, [46:40] sometimes it's it's like so important to [46:43] have [46:44] a combined mental model with the AI. So, [46:47] then this process uh [46:51] I I made a skill based on a blog post [46:53] article from Rahul Garg. [46:56] Uh and it's called design-first [46:57] collaboration. And basically, it's [46:59] simulating like a structured [47:01] conversation uh pattern that mirrors a [47:04] whiteboard exercise. So, you can think [47:07] that you're like drawing with the agent. [47:09] And what's nice is that it takes you [47:11] through one level by level. [47:14] And you can stop it on the way. [47:16] And uh you get kind of the same mental [47:18] model as the AI. [47:20] So, it starts with capabilities. So, [47:23] what does this feature do? [47:25] And then [47:27] uh components. What pieces do we need? [47:30] Uh [47:30] and then interactions. How do all of [47:33] these pieces communicate? [47:35] And then finally, con- uh contracts. [47:37] Like, what are the interfaces, the data [47:40] schema, and so on. [47:42] So, this is kind of the cheapest moment [47:46] to find errors and find misalignments [47:50] because you are in the planning phase [47:51] and it's taking you through like an [47:53] overview and not like these huge PRs [47:56] with 8,000 lines of code, then it's very [47:58] expensive to find misalignments. [48:02] So, um [48:03] here you see the [48:05] skill in action. So, now it has stopped [48:07] hard stop on level one capabilities, and [48:10] I can say like, "Okay, good. I agree." [48:12] And then it goes over to level two [48:15] uh components, and it has a review gate. [48:18] So, then I can actually catch errors on [48:20] the way. [48:22] Uh [48:23] and then it continues like this with [48:25] level three and four, and it ends with [48:28] making an ADR, architectural decision [48:31] record. [48:32] And that's my first commit, just this [48:35] one pager. So, it's super easy. It's [48:38] much easier for my colleagues to read [48:40] one page [48:42] with the architectural decision where I [48:44] actually say, "Okay, so I evaluated this [48:47] approach and this approach, but I went [48:49] for this one." And then they can give [48:50] feedback if I have any misalign- [48:53] misalignments [48:55] of the system or anything, they can help [48:57] me catch it now. [49:00] And then [49:02] now I can let loose of the agents [49:04] because they have all the context. So, [49:05] here you see they have the issues [49:07] tickets. It suggests how they should [49:10] split up the work. [49:11] So, it says like, "Okay, we will have an [49:13] agent back-end agent." It provided me a [49:16] to-do list here. Here it spins off the [49:18] first agent with the back-end task. This [49:22] is issue number 89 and 90. [49:25] And then the front-end agent. [49:28] And I owe No, sorry, not the front-end [49:30] agent, but I always interact with the [49:32] team lead. Now it spins off the [49:34] front-end agent. So, they will kind of [49:36] work in parallel. [49:40] And it goes on like this, and then [49:42] uh the testing agents get the tasks. Now [49:45] we write the test, [49:46] and it will run until all the tests are [49:48] green. Uh and this is possible because [49:51] they got all of this context to design [49:54] the architecture and everything. So now [49:56] it's just about like letting them loose. [49:58] And when I tried this, this was a beta [50:00] feature. Uh so you can check it out with [50:02] the agent teams. I think they call it [50:04] orchestrating a team of agents. [50:07] Uh but I don't think it's a beta feature [50:10] anymore. [50:11] So [50:13] but don't expect it to be perfect on the [50:16] first try. You have to iterate it with [50:19] it. So I usually find many things that I [50:22] want to improve. Uh also maybe decisions [50:24] that I took that I don't longer agree [50:27] with when I see it live. [50:29] So here for instance, you see how [50:32] uh [50:33] it added the filter here and I thought [50:35] it was very like cramped. So I didn't [50:36] actually like it when I saw it here. [50:39] Uh so then [50:41] uh you see after some iteration, we [50:43] moved it down here and go gave the stats [50:45] a little bit more space. And here you [50:48] see how I'm now using the test [50:50] implementation. So it loads the skill, [50:52] it has gotten the GitHub issue with [50:54] acceptance criteria, and it verifies the [50:57] criteria one by one. And here you see [50:59] now it's not me clicking, it's called [51:02] with Chrome that like [51:03] clicks and tests all the acceptance [51:05] criteria. And after some time, it will [51:08] then go ahead and update the GitHub with [51:10] the findings from the test run. [51:16] And then post it to the parent issue so [51:18] that I have the summary there of things. [51:24] And now over to verify. So [51:28] I think this is the [51:30] uh most [51:32] uh face with the most potential. And it [51:34] took some time for me to actually [51:37] understand it. I was like [51:39] doing all of this verification on my [51:41] own. But [51:43] uh [51:43] Anthropic's official best practice tip [51:45] number one is actually like, without [51:47] verification, Claude may produce [51:49] plausible looking code that doesn't [51:51] actually work. [51:52] So, to get a good workflow in the [51:54] verification phase is also very [51:56] important. [51:57] So, here you see different things that I [51:59] do in the verification phase. [52:02] Uh and I combine different things. So, [52:04] the first thing that I do is to have a [52:09] writer and then a reviewer. So, not [52:11] using the same agent session to write [52:14] the code and then review it. [52:17] Uh and here I use the PR review toolkit [52:19] a lot that I mentioned. [52:21] And then uh I also [52:23] use the verification before completion [52:25] that we have talked about, just like [52:27] proof before claim of success success. [52:30] And then it will run like the test and [52:31] lint and everything. [52:33] And then [52:34] uh this one is something I recently [52:36] started with, but actually having an [52:37] external judge uh [52:40] judge the work of Claude. So, for UI [52:43] work, I use uh [52:45] uh Gemini, [52:46] uh the flash model, and that is very [52:49] good for UI feedback. [52:52] I will show an example of that later. [52:54] And then uh to kind of like look in the [52:56] browser, just a visual uh [52:59] verification, and here I use both the [53:01] Chrome [53:02] uh agentic browser, [53:04] Playwright, and also Cosmos and [53:06] Storybook. So, that's a UI component uh [53:09] documentation [53:11] uh [53:12] library that I can show you. [53:15] So, here you see [53:17] an example using Gemini judge. So, [53:21] uh [53:22] I access this model through Open Router [53:24] with just one API key, then you can [53:26] access many different uh [53:29] uh models. So, it will then go ahead to [53:32] send then this uh I use this to review [53:35] every slide in this presentation. So, [53:37] then it will send a PNG file [53:41] uh [53:41] through the API, and then I will get [53:44] some score and suggestion for [53:45] improvement. [53:47] So, here you see that I'm saying like [53:48] review slide number 49, [53:51] and it will [53:52] review it by [53:54] eight different categories and give them [53:56] score. So, here you see that okay, the [53:58] visual polish [53:59] didn't get a good score. So, it will [54:01] then actually suggest something that I [54:04] can improve. [54:05] And it will then ask like, "Should I [54:07] trigger pixel theme brainstorming to [54:10] generate a new illustration with [54:13] nanobanana?" So, this is also [54:15] reachable through the open router API. [54:21] And I usually I did this on my own [54:24] first, [54:25] and I was like writing a lot of texts, [54:27] and I was like, "Oh, this takes so much [54:29] time." Like, an AI can do this review so [54:31] much better than me. So, then after [54:33] doing [54:34] getting the agent to review it, it got [54:37] so much faster. [54:40] And of course, there's many things often [54:42] I picked that the agent doesn't, but [54:45] it's just about getting some help along [54:47] the way to automate things. [54:50] And here you see the [54:53] how I can get the fast visual overview [54:56] of all the component component variants. [54:59] So, this is also very good if you're new [55:00] to a code base. The first thing thing I [55:02] did, for instance, with the CRM system [55:04] was actually just to get out up all the [55:07] components that was used, so that I can [55:09] click through each of them and see the [55:11] variants. And then when I'm making [55:13] something new, I can actually pick and [55:15] choose from things we have. [55:17] And uh [55:19] I would say that this [55:21] forces you to have better um [55:24] component design, because they need to [55:27] live [55:28] isolated outside of the app in Cosmos. [55:32] Uh so, Cosmos is just for React [55:34] components, but I think Storybook is [55:36] more versatile. [55:40] And yeah, so this is another thing that [55:42] I did [55:44] actually the last 2 weeks because we [55:47] were on a very short deadline and we had [55:49] to produce so much. So I was like, okay, [55:51] I need to work faster. So then I [55:53] actually made an autonomous flow [55:56] skill because [55:59] I was very like in the explore plan [56:03] phase I'm very tight in everything [56:06] making decisions. In the code phase I [56:09] let go and in the verify phase I usually [56:12] did thing very manually but then I was [56:14] like, okay, but if I first automate it [56:17] and then I can jump in it will I will [56:19] catch I don't need to catch that much, [56:21] right? Because it has already done a [56:24] verification flow. So here now step [56:27] number one it will actually [56:29] self-verify [56:31] with the skill verify before completion. [56:33] Then it does a code review [56:36] with the six different agents gives a [56:37] summary and actually goes ahead and [56:39] fixes things that it finds. Then it does [56:42] a browser test without me watching [56:44] and actually [56:46] make sure that acceptance criteria are [56:47] met. [56:48] And then because [56:50] all the way in the explore plan it has [56:54] had many agents that are running and it [56:56] will make many small commits. So you [56:58] have like 30 commits and it's very tough [57:01] to go through and review when it's so uh [57:05] split it. So then I made a skill called [57:07] commit dance where it will actually go [57:09] ahead and make [57:11] temp file with all the commits and all [57:13] the [57:14] history and then it will go ahead and [57:16] suggest a more pedagogical cluster of [57:19] commits so that it's easy for a human to [57:21] review. So it will go ahead and then [57:24] make a clean narrative. [57:26] And then it will will create a PR [57:29] push it with a the clean narrative and [57:31] then in GitHub, we then have an [57:33] automated code review. So then the bot [57:36] will actually do a review and leave some [57:38] comments. [57:39] And then it will actually go ahead and [57:41] read the the [57:43] the bot reviews and then fix them and [57:47] actually answer the bot. And then I jump [57:49] in [57:50] after that because then it has kind of [57:52] like catched a lot of things before me [57:54] jumping in. And this is still a PR. So [57:57] it's not not accepted at all. It's still [58:00] in a work in progress phase. It's just [58:02] that I've had a a lot tighter process to [58:05] increase the quality of the code. [58:08] And here you see uh now how I get like [58:11] up to speed because this is actually to [58:14] make this presentation, I use um [58:17] conductor, which is a way to have [58:19] different cloud agents running in [58:20] parallel. So here you see that I can [58:23] like navigate between the chats. I give [58:25] this one I started like create a PR. [58:28] Uh and then this one it has actually [58:30] created a PR. I usually watch them. I'm [58:32] just showing you that you can very [58:33] easily like merge them. [58:35] I gave the first chat the task and here [58:37] you see that I have like 136 different [58:40] um [58:41] done PRs that I have already merged. And [58:44] this is like for each slide. So I can be [58:46] like, okay, quality check [58:49] the slide information. Is something [58:50] outdated? Translate it to English like [58:52] so many small things that agents can run [58:55] in parallel [58:56] uh to get me up to speed. And what's [58:58] nice with conductor is that I can like [59:00] you saw that I can see the file [59:02] overview. I can see the [59:05] the changed files. I can also run [59:09] uh up [59:10] a version of the app [59:12] in this chat so that I can test just [59:14] that. [59:15] Uh [59:16] so it's very nice. [59:18] And there's also uh Warp, which is a [59:21] modern terminal. So with one click, I [59:23] have kind of a full environment. So here [59:25] it opens up like the backlog, a cloud [59:28] session that has the access to the BFF [59:30] logs on disk, a war tunnel, which is our [59:33] identity provider, the web app, so I can [59:36] test, and then cosmos here, so that I [59:39] can [59:40] go through the different components. So [59:43] this is very nice with tab configuration [59:45] that you can just like get the app done. [59:48] And I can also have work trees where I [59:53] then have for different features that [59:55] I'm developing. So here you see that it [59:57] opens like the same, the back end [60:00] and the front end and cosmos, and then I [60:03] actually get my own [60:05] uh URL. [60:07] So I don't need to kind of remember all [60:09] the ports where I'm testing what because [60:12] I see, okay, feature one is on this URL, [60:15] so I can test that. And I do this with [60:19] portless, so I warmly recommend [60:22] portless, it's very nice. [60:24] It's from where it sell. [60:27] And then [60:29] what's nice is that here you see now [60:32] that I have four different tab groups [60:33] going on. So maybe in the first one, [60:36] this is checked out in dev. [60:38] And this one I usually leave open, so I [60:40] use it to review [60:42] PRs from others, but I also do it for [60:45] bug checking or checking something that [60:48] is off on my setup and so on. [60:50] And then in the pink one here you see [60:53] I'm working with the feature one for [60:55] instance, and this one is in [60:57] brainstorming and it needs my high [60:59] attention because it's many decisions. [61:01] So I'm usually like accepting many [61:03] choices and watching the HTML pages [61:06] coming up. [61:08] And then in the next tab, feature two, [61:11] for instance, maybe that's come to the [61:13] ADR phase, so I'm actually waiting for [61:15] review from colleagues on GitHub. So I [61:20] can't do much there. And then on the [61:22] last one, maybe that has come to the sub [61:25] agent [61:27] implementation phase. And here, [61:29] I have been very close to it in the [61:32] explore and planning. So, now it's just [61:34] like lower little oversight. It just [61:37] needs to get done. And this can run like [61:39] sometimes for half day and sometimes for [61:42] like a whole day without me watching. [61:44] And then I jump in afterwards. [61:48] So, we are at the end. [61:50] So, five takeaways. [61:52] The first one, [61:54] AI is just a tool, nothing more. And [61:58] what makes it magical is your brain [62:00] combined with it. [62:02] And I like to compare it like just [62:04] imagine you have a [62:06] palette and paint and a pencil. Some [62:09] makes a stick drawing, [62:12] but others make Picasso. So, it's like [62:14] you need to practice. It's an art. It's [62:16] engineering. Uh but you need to [62:18] practice. And it's your brain with it [62:20] that makes it magical, not the AI tool. [62:24] And then, uh the workflow is the [62:26] product. Every finished task that you [62:29] get is just a test that your workflow [62:31] works. [62:33] And you own all the generated code. [62:37] Don't like blame the AI later. It's like [62:39] your responsibility, your process. [62:42] And the key skill to the future, I [62:45] think, is adaptive capability, being [62:47] polymorph, the ability to learn and [62:50] change context. [62:52] And finally, without verification, [62:55] Claude produces plausible [62:57] looking code that doesn't actually work. [63:01] So, with that, I would like to thank [63:02] you. And I would love feedback. That's [63:06] the only way I improve. So, if you want, [63:09] you can leave them by scanning this QR [63:11] code. And also, let's connect. This is a [63:13] QR code to my LinkedIn. [63:16] And if [63:18] uh was just a taster, but Kodemaker [63:20] actually now has two-day courses. So, if [63:24] you are interested in the full course, [63:27] you can scan this QR code. And during [63:30] this week, we have a [63:32] discount code uh called NDCi, if you [63:36] want that. [63:37] Thank you so much. [63:40] >> [applause]