Design Engineering with Maggie Appleton

Technological concepts & product/engineering analysis

• Why designers need engineering depth (web/software stack awareness)

  • Poor design outcomes happen when designers don’t understand how systems work: app data flow, loading time, and race conditions.
  • She argues that “bad design” is often an engineering-constraints mismatch, not just aesthetics.

• Agents will shift designers’ workflow, but won’t remove core design thinking

  • Agents can help designers experiment faster and generate implementations.
  • But the designer still must define requirements, boundaries, and the right “system shape.”
  • She expects agents to become a coach/learning tool, helping designers learn from engineering feedback (e.g., why certain errors/conditions occur).

• “Gaslighting” risk from inconsistent model behavior

  • Models can seem impressive one moment and be wrong later; this inconsistency can feel like being “gaslighted.”
  • The underlying issue is unpredictability/stochasticity: outputs vary with context, random factors, and changing models.

• Sketching/handwritten artifacts as a critical interface to thinking

  • Even with AI/agents, she emphasizes pen-and-paper and notebooks for fast externalization of spatial ideas.
  • Her argument: agents handle text well but struggle with spatial/visual design reasoning (e.g., spacing, sizing, overlap) unless the human clarifies intent via visuals/diagrams first.

• Design of interfaces for agent planning (reducing decision fatigue)

  • She critiques agent UIs that require long interactive questionnaires (e.g., A/B/C repeatedly), which causes user fatigue and superficial decision-making.
  • Her proposed planning-interface approach:
    • Move beyond CLI to richer visual environments.
    • Use “stacks/accordion” cards or mini decision documents with embedded diagrams.
    • Show visuals for quantitative/architecture decisions (e.g., diagrams, state machines, dataflow).

• Jigs/variables to make “Figma-like” design controllable by agents

  • Borrowing from woodworking: jig + sliders/variables to adjust uncertain properties (header size, colors, animation curves).
  • Workflow idea: give agents a mockup + “jig” controls, then iterate to converge to correct values in a live prototype.

• Prototyping changes with agents

  • Agents can turn sketches into working React/component-based prototypes much faster.
  • Instead of hand-polished Figma click-throughs, she can generate more realistic prototypes that users can interact with (fewer “fake UI” artifacts).
  • She frames prototyping as building ambitious interactive systems and iterating quickly.

• UX/UI paradigm: familiar primitives often win

  • In Elicit’s work on literature/data extraction, she describes novel AI interface experiments (canvases/cards piles, card-linear layouts).
  • User feedback consistently favored a table-based interface, minimizing cognitive load—suggesting AI interfaces still benefit from familiar UI primitives.

• Tables/side panels/cards as enduring “AI interface building blocks”

  • She argues many formats (tables, panels, documents, cards) remain effective and should be expanded rather than replaced entirely.

• Multi-agent coordination problem (“one developer, dozens of agents, zero alignment”)

  • She references GitHub Next’s focus on the gap between:
    • agent coding speed, and
    • lack of tools for multi-user, real-time reconciliation of plans/decisions.
  • Core pain: no shared primitive for agreeing on a solution before implementation.
  • Proposed direction: first-class collaborative primitives (shared “sandboxes” like Slack/online workspaces) plus an audit trail for who accepted which decision.

• Proactive/background agents research

  • GitHub Next explores how to use many background agents without annoying users:
    • agents that do useful work continuously
    • consumed in a low-interruption way
  • Open question: how to consume outputs from many agents efficiently while staying non-intrusive.

• Design-agent generation can harm originality

  • Generated designs may look “correct” but feel culturally generic/AI-like.
  • She suggests humans may be needed for novel, context-aware aesthetics; purely agent-produced UIs could converge toward sameness.

• Practical note on Figma accuracy

  • She uses Figma for rough structure and design intent, not pixel-perfect precision, because real browser rendering varies (fonts, breakpoints, responsiveness).
  • Typical approach: prototype early in the browser, then adjust.

Review / tutorial / guide-like elements mentioned

• Externalization workflow (pen/paper → diagrams → agent implementation)

  • Use notebooks and sketches to clarify spatial layout before prompting agents.

• Agent UI/interaction design for planning

  • Avoid repetitive questionnaire loops; use decision cards with visuals (diagrams, state machines, dataflows).

• Variable-driven design prototyping (“jig” sliders/controls)

  • Create controllable mockups with sliders/variables; let agents tune values iteratively.

• Shared multiplayer agent workspaces

  • Use or study shared sandboxes (Slack-like collaboration) to coordinate multiple agent contributions and decisions.

Main speakers / sources

• Maggie Appleton (engineer-designer; primary speaker)
• Podcast interviewer/host (implicitly referenced as the questioner throughout)

Company/tool sources discussed

• GitHub Next
• Antithesis (sponsor; hostile-condition verification/debugging visualization)
• Turbopuffer Vector & Full Text Search (sponsor; AI infrastructure/search)
• Entire (sponsor; Git hosting/agent parallelism, mirroring, history capture)

Referenced third-party figures/works

• Brett Victor (interactive/live feedback inspiration)
• Robin Sloan (“home software” concept)
• Ken Beck, Ward Cunningham (historical references to design vocabulary/patterns)
• Jorge / “Oh, my craft” (quoted developer perspective on reduced need to micromanage details as models improve)
• Mentions of Claude, Codeex, OpenAI (tools/models evaluated in her workflow)
• Mentions of GPT-3.5 / GPT-4 timeline and agent ecosystem concepts (MCP, skills, etc.)