Agentic Design Fundamentals

What actually changed when capable coding agents, MCP, and design-as-code formats arrived at the same time, what an agent is and is not, where the new designer-agent loop differs from the tool-centric loop, and what stays firmly human.

• Explain why the shift to agentic design happened now, naming the three converging changes behind it.
• Define an agent in operational terms — reads, plans, acts, verifies — and distinguish it from a chatbot.
• Describe the agentic design loop and identify which steps are agent-run and which are human gates.
• Compare the four major CLI agent platforms at a level useful for choosing a starting point.
• Name the design responsibilities that do not transfer to agents: taste, intent, judgment, and accountability.

The loop from Module 1 slowed down to working speed: what each step looks like in a real session, how to treat the agent as a junior design partner rather than a vending machine, and where the loop most often breaks.

• Walk each loop step — brief, generate, critique, revise, ship — as a concrete session activity.
• Use plan mode and review gates so corrections happen before code exists.
• Apply the show-early, iterate-small habit to keep agent runs reviewable.
• Recognise the three most common loop failures and name the fix for each.

The brief is where design intent becomes executable. This module covers the anatomy of a design brief, the difference between vague and specific prompts in measurable terms, and how research packets feed briefs that an agent can actually act on.

• Diagnose why vague prompts produce generic output, using before-and-after evidence.
• Write a seven-line design brief covering situation, user job, audience, direction, constraints, output shape, and review criteria.
• Translate taste and visual direction into behavioural constraints an agent can follow.
• Assemble a research packet as briefing input for larger tasks.

Briefs carry task-specific intent; the harness carries everything durable. This module covers the instruction hierarchy, project instruction files, path-scoped rules, skills, and design tokens as agent instructions — the layer that makes output consistent across sessions and people.

• Explain the instruction hierarchy and what loads when in a typical agent session.
• Write a CLAUDE.md or AGENTS.md that encodes design rules an agent reliably follows.
• Use path-scoped rules and SKILL.md files for procedures that only some tasks need.
• Treat design tokens and DESIGN.md as machine-readable design instructions.

Why diffable design files are the foundation the rest of the workflow stands on, what the current agent platforms and connected canvases actually offer, and how to pick a starting stack without betting the team on a moving target.

• Explain why binary design files block agent workflows and what diffable alternatives exist.
• Compare the four major CLI agent platforms on the dimensions that matter for design work.
• Describe the connected-canvas landscape and where each tool fits.
• Choose a starting stack for a team and defend the choice.

The closing module: how to critique agent output so it improves, which checks can be made executable, the failure modes that keep recurring, and an honest account of what agents are still bad at — finishing with a ship checklist and where to go next in the curriculum.

• Run a structured critique loop with an agent using named dimensions rather than vibes.
• Use screenshot evidence and visual QA to verify implementation against intent.
• Encode anti-slop rules and executable gates that catch recurring failures automatically.
• State clearly what agents are still bad at and design the workflow around those limits.