5 min read

Run a Team of AI Agents as a Designer

AI

Craft

Computer Science

Engineers are working faster than ever. Designers are now the bottleneck.
We either absorb the pressure and work faster or teams begin working around us.
Agentic design workflows give us another option: scale our judgment instead of simply working longer.
Most designers begin with one agent in one chat, working on one feature at a time. But as the amount of work expands, we need to move up the same orchestration ladder as engineers. We move from using individual agents to managing systems of agents.
We can expand our agentic leverage across four dimensions: scale, time, place, and autonomy.

Choose the lever that matches the work.

Scale

A single agent works serially. It can audit one flow, implement one feature, or critique one screen. But broad product work contains dozens of surfaces, viewports, and states.
A dynamic workflow breaks that work apart. Claude plans the work, gives each surface dedicated attention, verifies the findings, and combines the results.
Imagine asking a swarm to audit an entire product:
  • Discover every surface, journey, and important state.
  • Assign each to a separate agent.
  • Check design-system compliance.
  • Audit against UX heuristics.
  • Find experiential problems.
  • Create a prioritized Linear project with screenshots and separate tickets.
  • Send me a slack message with a link when you're done.

One brief becomes bounded parallel work, then one verified result.

The benefit is not merely speed. Each agent gets clean context and a bounded assignment. One surface does not crowd another out of the conversation. The work happens in parallel, then returns as one verified result.
I recently used this workflow in production to align our design prototyping codebase and production codebase one-to-one across every major product surface.

Time

Most agent work is one-off: ask for something, receive the result, and end the session.
But design contains work that repeats, persists, or begins when something else happens. There are three useful temporal patterns:
  • Loop: check repeatedly. Watch a Slack channel and create prototype variants based on feedback.
  • Goal: continue until a condition is true. Iteratively improve the Lighthouse accessibility score of the site while still meeting the aesthetic standard encoded in DESIGN.md.
  • Routine: run on a schedule or event. Inspect frontend changes in your product area whenever someone opens a pull request.

The trigger determines how the agent keeps working.

Stay with the feedback, not the terminal

Imagine a loop watching a Slack channel for feedback. When customer success or sales flag a possible UX improvement, the agent reads it, checks it against the standards in your product and design docs, and builds a preview prototype in a separate worktree, then runs it locally so it is ready to look at.

Watch the product continuously

Now imagine a routine that runs whenever a frontend pull request touches your product area. It inspects the visible change, captures the affected states, and sends you a summary with screenshots or a video walkthrough.
Designers cannot continuously watch the entire implementation surface. Agentic routines can.

Place

Local agents work on your machine. They stop when you close the lid. Cloud agents keep working independently.
This changes where design work can happen:
  • Start a prototype task from your phone.
  • Ask Claude to implement it on a branch.
  • Go to meetings, critiques, or customer calls.
  • Return to a working prototype and screenshots that you can review.
  • Continue hacking on it from your laptop.

Execution and attention no longer share the same clock.

Our workdays are fragmented by reviews, customer research, collaboration, critiques, and meetings. Cloud execution turns those periods from fractured time into delegated execution time.
Work no longer has to happen where your laptop, or your attention, is.

Autonomy

Scale, time, and place expand what a workflow can cover. Autonomy changes who designs the workflow itself.
In an explicit dynamic workflow, you might say:
Audit every user flow. Use one agent per surface, independently verify the findings, then consolidate them.
You have already decided that the task requires several agents, how to divide the work, how to verify it, and how to combine the result.
With Ultracode, you might say:
Find the most important inconsistencies across this product and produce a verified remediation plan.
Claude decides whether it needs one agent, several subagents, one dynamic workflow, multiple workflows, or another verification stage.

More autonomy delegates workflow design—not judgment.

Dynamic workflows let you become the manager. Ultracode lets Claude become the manager.
You have not given up judgment. You still define the intent, constraints, and standard of quality. Claude manages the execution structure.

A pathway to greater autonomy

Here's a path you can take as a designer to climb the ladder of autonomy:
  1. Delegate: give one well-scoped task to one agent.
  2. Parallelize: let several agents cover a larger product surface.
  3. Persist: let agents continue across time and triggers.
  4. Detach: let work happen away from your machine.
  5. Orchestrate: let Claude decide how the work should be organized.

Each step moves execution coordination away from you.

With tools like these, we move from designing interfaces to designing systems that extend our design judgment.

Scale your judgment

Over time, our jobs will continue to evolve away from making every artifact, reviewing every screen, remembering every follow-up, noticing every change, and coordinating every task.
Our work is moving towards:
  • Defining intent.
  • Encoding standards.
  • Creating evaluators.
  • Designing workflows.
  • Providing experiential verification (aka design taste).
This is close to the division of labor already visible in agentic coding. In a typical Claude Code session, people make most planning decisions while Claude makes most execution decisions.
Agents will execute more and more while designers remain responsible for what deserves to exist and whether the result is good.
Designers will either learn to scale their judgment or get worked around.

Worth your inbox.

The occasional note that actually earns the open.

Free for subscribers

  • 3 production-ready Claude Code skills
  • Invites to free AI design office hours
  • The CLAUDE.md I use to design faster
← All writing