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)