Video summary

Polymorphic Mindset - Marina Santos Haugen - NDC AI 2026

Main summary

Key takeaways

Technology

Technological focus: “Agentic AI workflow” + “polymorphic mindset”

  • Marina Santos Haugen argues that with fast-moving agentic AI, small teams can do much more—but the real value comes from workflow/system design, not from the AI agent itself.
  • She frames her approach as a polymorphic mindset: the same engineer “shifts forms/roles” depending on context—analogous to polymorphism in programming (same interface, different behavior).
    • In practice, that means switching hats across product/UX/engineering/security/debugging tasks instead of working strictly in one role.

Core idea: design the system and workflow so the team can reliably produce value with agentic AI.

Product/Team analysis and supporting claims (from referenced reports)

  • AI superpowers promise vs reality: AI enables humans to gain “superpowers,” especially via agentic workflows.
  • Task delegation bottleneck: Most teams get stuck in task-to-assistance/delegation rather than workflow reinvention (cited: “over 85%”).
  • High failure rate due to process: Many agentic projects fail not because of technology, but because of process (cited: “over 40%”).
  • AI as a coworker, not a tool: Leaders increasingly treat agentic AI like a coworker (cited: “76%”).
  • Silo-breaking: AI can break down organizational silos and help cross-functional teams produce more breakthroughs (cited: “three times more”).
  • Budget misallocation: Most AI budget goes to technology rather than people/training/process (cited: “93% tech vs ~7% people”).
  • Individual AI doesn’t automatically create team value: Without deliberate workflow design, individual use can erode collaboration.
  • Transformation requires redesign: Organizations must redesign workflows (not just deploy tools).

Core engineering/product claim: workflow is the “product”

  • She warns that AI can seduce engineers into generating lots of code quickly (“click and done”), producing shoddy outputs.
  • Emphasis: engineers must guide and own output—AI-generated code still belongs to the developer’s responsibility.
  • Escalation example: “cost of misunderstanding the system”
    • one bad plan/spec can propagate into 10–100x / 1000x bad work
    • one bad infrastructure line can explode into hundreds of thousands of bad code (described via a real experience with large PRs + a refactoring trap)

Her proposed workflow: “Autonomy of a workflow”

She uses a non-linear loop with phases:

  1. Exploration
  2. Planning
  3. Code + Verify

Key ideas:

  • Treat each task as a test of your workflow.
  • Design workflow components as reusable blocks.

“Blocks” powering the workflow

1) Configuration (permission + context management)

Practices and intentions:

  • Avoid “death by prompt” via permission housekeeping (e.g., /permissions, auto-mode).
  • Use “inside boxes” / reasoning-style output controls via configuration commands (to control pattern/reasoning visibility).
  • Maintain good context windows with compact/clear settings and context/status indicators.

Example plugin/skill:

  • CLA MD improvement: grades/assesses a “Claude Markdown” (CLAUDE MD) file and suggests improvements, with a “revise” command to learn from a specific session.

2) MCP servers (“tool connectivity” layer)

She uses MCP servers to let agents access external tools, with examples such as:

  • Design: Figma integration
  • Issue tracking: Linear, Jira?, GitHub issues
    • creates issues/attaches details and automates bug reporting
  • Documentation: “Context 7” + Notion
    • fetches fresh/internal docs because older training data can be outdated
  • Security analysis: a “SASP”/security MCP server
  • Testing automation: Playwright for browser testing + demo recording

She also suggests listing available MCP servers with something like slmcp.

“Context 7” example points:

  • Uses “fresh docs” for dependency changes and breaking changes.
  • Uses it for research: mapping a complex decision tree into readable text/workflows for non-technical stakeholders.

3) Skills and plugins (reusable “recipes”)

Core distinction:

  • She emphasizes: build skills, not agents (citing an Anthropic point from an AI engineer talk).
  • Skills are packaged recipes (often in markdown).
  • Plugins bundle skills and hooks.
  • She strongly prefers official/known skills (Anthropic-provided) and does not blindly trust third-party marketplace skills.

Examples of workflows realized as skills:

  • Pixel theme (custom)
    • generates consistent-themed illustrations/landscapes
    • required many iterations to reach quality
  • Superpowers (larger toolkit)
    • multiple skills across planning → implementation → scaling → quality
    • brainstorming that outputs structured HTML visualization to avoid fatigue from huge outputs
    • plans broken into testable steps
    • test-driven development + systematic debugging
    • sub-agent-driven development with separate context windows
    • strict “verification before completion”:
      • runs tests/lints
      • checks acceptance criteria rather than trusting “I’m done”
    • PR-review related tools:
      • “sending code review comments” when score exceeds a threshold (e.g., >80%)
      • a more customizable local PR review mode
  • Front-end design skill
    • aims to avoid generic “AI-looking” UI
    • instead matches a design profile / customer needs
    • demonstrates two different processes leading to very different outcomes (e.g., “journal-like” vs “boring black/white”)
  • Feature depth (7-phase pipeline)
    1. discovery
    2. exploring (triangulation using multiple agents)
    3. clarification (hard stop)
    4. architecture (up to 3 options with pros/cons)
    5. implementation
    6. review (simplicity/correctness/conventions checks)
    7. wrap-up
  • Documentation skill example
    • analyzes a large Excel-like requirements document (56 columns, 370+ rows)
    • extracts mandatory/conditional fields
    • produces a prototype wizard for PM review
  • Security review skill
    • scans many files, reports high/medium/low findings
    • integrates into CI
    • recommends automations (hooks, permission rules, MCP server setups)
  • Custom “skill creator” tooling
    • helps structure skills
    • validates them via a “writing”/quality check loop

Verification-first principle (anti-hallucination / reliability)

  • She claims verification is critical: without it, Claude may generate plausible-looking but non-working code.
  • She uses:
    • separated writer vs reviewer sessions/agents
    • PR review toolkits
    • verification-before-completion
    • external judge models for UI feedback:
      • Gemini via OpenRouter
      • scoring slides by categories and suggesting improvements (including triggering image/theme generation workflows)
    • UI validation:
      • browser automation (Chromium/Playwright)
      • Storybook/Cosmos for component browsing

Automation for speed on tight deadlines

  • She describes building an autonomous flow skill to reduce manual oversight across phases:
    • self-verify
    • multi-agent code review and auto-fixes
    • automated browser tests for acceptance criteria
    • a “commit dance” skill to rewrite/cluster many auto-commits into a cleaner, human-reviewable PR narrative
  • Orchestration:
    • uses orchestration tools (conductor) to run multiple agent chats in parallel and merge resulting PRs

Practical tooling and environment notes (developer ergonomics)

  • Mentions terminal/workspace tools:
    • Warp terminal
    • Portless (Vercel) to reduce port management and provide URLs for features
    • Worktrees for separate feature branches
    • Cosmos/Storybook for component variant browsing
  • Workflow multitasking:
    • uses multiple “tab groups” aligned to stages like brainstorming, architecture review waiting, implementation, PR review, and bug checks

Main speaker(s) / sources

Speaker

  • Marina Santos Haggin Full-stack software engineer; consultant at Kulak; background in industrial economics & tech management; formerly at DNB.

Referenced sources / reports (not direct speakers)

  • McKinsey (“One year of agentic AI”)
  • BCG (agentic AI workflow findings; task-assistance/delegation and workflow reinvention value)
  • Additional referenced report/organization: BCG and PNG (as cited in subtitles)
  • Anthropic
    • advice to build skills instead of agents
    • official skill ecosystem
  • OpenRouter (used to access models for judging UI slides)
  • Gemini / Claude (models used in examples)
  • OWASP (used for vulnerability scanning context)

Original video