Agentic Design: When Agents Build the Interface

For decades, we’ve designed software backward.

We assumed our users were human, so we built for eyeballs and fingertips. Human-centered design made sense, but it has a hard ceiling: the eight billion people on Earth. That is the total addressable market for traditional UX.

A new, unbounded user is emerging: the AI agent. Agents scale to trillions, work without sleep, and spawn on command. This isn’t about replacing human-centered design, which will grow with the world’s population. It’s about capturing a new, exponentially larger market.

Our design principles, frameworks, and tools all assume a human is looking at a screen. We are ignoring the vast market of agents that need their own design language. The future has two users: one who clicks buttons and one who executes commands. We have only been building for the first.

Welcome to Agentic Design (AD), the discipline of building for agents first. This isn’t human-centered design with a bot layer. It’s an agent-first architecture where the visual interface is a pleasant afterthought.

The Great Inversion: From GUI to CLI

Software design once followed a predictable path from the command line to the graphical user interface. We called this progress.

But agents don’t need your GUI. They need deterministic interfaces, clear contracts, and measurable feedback loops. The terminal, which we spent decades burying, is their perfect interface.

After decades of burying the command line, we return to it as the ultimate design primitive.

Principle 1: Language Is the Interface

Agents think, reason, and act in text. A visual interface for an agent is a radio for the deaf. This changes how we build systems.

A human-first design might look like this:

1. Button: ‘Export Report’
2. Dialog: ‘Choose format: PDF, Excel, CSV’
3. Progress Bar: ‘Generating…’
4. Result: A file download prompt.

An agent-first design is a single command:

$ ./tools export-report --format csv --output report.csv
{"status": "success", "bytes": 45621, "rows": 1843}

The agent doesn’t see a button. It sees a command, its parameters, and the data it returns. The documentation is the interface.

Principle 2: Code Generates the Design

Here is the paradox of Agentic Design: The artifacts of design—HTML, CSS, schemas—are not executable. But the practice of design is using code to generate, evaluate, and refine them.

The terminal becomes a design studio where code forges non-code artifacts:

# 1. Generate a design artifact (HTML) with code.
./tools generate-template --style minimal --columns 3 --output design.html

# 2. Evaluate the artifact programmatically.
./tools analyze-design design.html
{"contrast": 7.2, "readability": 94, "mobile-ready": true}

# 3. Use feedback to iterate with another command.
./tools optimize-design --input design.html --improve "contrast:8.5"
{"status": "optimized", "contrast": 8.6, "changes": 3}

# 4. Validate the final artifact against specifications.
./tools validate-accessibility design.html
{"wcag-aa": "pass", "screen-reader": "compatible"}

The design (non-code) is declarative, while the tools (code) are executable. In AD, we express design through:

• Guardrails: Rules that prevent destructive actions.
• Directives: Unambiguous instructions for agent behavior.
• Templates: Skeletons (HTML, JSON) that agents populate.
• Constraints: Boundaries expressed as configuration, not logic.
• Specifications: Declarative descriptions of desired outcomes.

These are architectural decisions, expressed as protocols and managed by code.

Principle 3: Feedback Loops Are the Engine

Human design relies on subjective feedback: ‘Does this feel right?’ Agentic Design requires objective feedback: ‘Did this execute correctly and meet the performance criteria?’

This requires building measurable feedback loops into every part of the system.

• Traditional Design Process: Designer → Mockup → Human Review → Subjective Iteration

• Agentic Design Process: Agent → Generate → Execute → Measure → Self-Evaluate → Regenerate

An agent must know if its design works without a human. Every decision must be testable and measurable through code.

Principle 4: Constraints Are Liberation

Great design isn’t about unlimited options; it’s about execution within boundaries. Agentic Design takes this to its logical extreme: constrain everything.

Unconstrained parameters invite chaos.

# Bad AD: Unconstrained
generate_layout:
  colors: any
  spacing: flexible
  iterations: unlimited

Constraints create a focused problem space where agents can find a valid solution.

# Good AD: Fully Constrained
generate_layout:
  colors: ["#000000", "#FFFFFF", "#FF0000"]  # Exactly 3 allowed colors
  spacing: [8, 16, 24, 32]                 # Only these pixel values
  iterations: 10                           # Hard stop
  grid_columns: 12                         # Fixed system
  breakpoints: [320, 768, 1024]            # No other screen sizes

Constraints aren’t limitations—they are the guardrails that make autonomous design possible.

The Swarm: Parallel Design

A human designer is single-threaded. They explore one path at a time. Agents have no such limit.

Using tools like Git worktrees or Jujutsu (jj) workspaces, you can orchestrate a swarm of agents, each exploring a design direction in an isolated environment.

# Create isolated environments for parallel exploration
git worktree add ../design-dark -b feature/dark-theme
git worktree add ../design-mobile -b feature/mobile-first  
git worktree add ../design-a11y -b feature/accessibility

# Launch agents in parallel, each with a specific goal
(cd ../design-dark && claude "Design a dark theme for OLED displays.") &
(cd ../design-mobile && claude "Redesign for mobile-first. Max 50KB CSS.") &
(cd ../design-a11y && claude "Achieve WCAG AAA compliance.") &

While a human sketches one concept, your swarm has already:

• Agent A: Generated 50 dark theme variations.
• Agent B: Tested 30 mobile layouts across all breakpoints.
• Agent C: Validated accessibility against 15 screen readers.

This isn’t just faster. It’s a new process—a shift from linear exploration to parallel evolution. You don’t guess the right path; you explore all paths at once and let an orchestrator merge the results.

The Code Is the Design

Here is the truth that will define the next decade of software: Agentic Design is written, not drawn.

Figma and Photoshop were for an era when we needed to see a design before building it. In AD, the design is the code. Not a mockup, not a representation. The code itself.

// This isn't a design tool. This IS the design.
const design = {
  layout: 'grid(12, gap: 16)',
  color: palette.select(['#000', '#FFF'], 'high-contrast'),
  typography: scale.generate(1.618, 'golden-ratio'),
  spacing: units.constrain([8, 16, 24, 32]),
  behavior: 'deterministic',
  validation: 'continuous'
};

// The agent doesn't draw this. It executes it.
render(design);

The AD professional is not a traditional designer. They are a:

• Design Programmer who encodes aesthetics into algorithms.
• Constraint Architect who defines the boundaries of the possible.
• System Orchestrator who conducts swarms of generative agents.

The shift is total: from Photoshop to Python, from mockups to modules. While you drag rectangles, an agent writes, tests, and deploys the code for a million of them.

The future of design is not visual. It’s executable. It’s not about how it looks; it’s about how it runs.

The pixels are dead. The mockups are dead.

Long live the code.