Month-by-month feed of what shifted, who was hiring, and how Starter, Scaler, and Titan teams actually worked.
61 synthesized monthsin the data layer. Stage breakdowns (Starter / Scaler / Titan) are available for 2026 only — earlier months show under the All segment but won’t appear under stage filters until the design-context pipeline runs further back.
Solo operators and tiny teams run personal software and agent fleets. The studio is one person with taste.
Claude → Cursor → Figma Make
At this scale the person with taste is the entire company. Everything else is tooling.
Series A-B teams run flat. One CD, a Design Engineer or two, and apprentices learning taste on the job.
Figma (canvas + Make) → Cursor → in-house agent orchestration
Solo operators ship full products and brands in a weekend using agent stacks they assembled themselves.
Figma Make → Cursor → Lovable
At pre-seed, one person owns the whole surface. They write the code, set the brand, and direct the agents. There is no handoff because there is no one to hand off to.
Series A and B teams run with half the designers they would have hired in 2024, and twice the seniority.
Figma + Figma Make → Cursor → internal agent orchestration
Solo and tiny teams run on personal software. The founder-designer builds their own tools and ships product through an agent stack.
Figma Make → Cursor → Lovable
At this size, one person owns taste, code, and distribution. AI makes that bundle viable; it doesn't make it common.
Series A/B teams run senior-only design pods that direct agents. The junior seat is gone or rebuilt as a formal apprenticeship.
Figma + Make → Cursor → internal agent orchestration
Solo operators ship entire products without hiring anyone. The studio of one becomes the default starting shape.
Figma Make → Cursor → Claude
At pre-seed and seed, there is no design team to build. The founder either has taste and can direct agents, or they ship generic slop. The role compresses design, engineering, and product into one person.
Series A/B teams stop rebuilding the old pyramid. They hire four Design Engineers instead of one lead plus three juniors.
Figma Make → Cursor → Linear
Solo founders ship with a personal agent stack. Design is a taste filter on top of generation.
Figma Make → Cursor → Lovable
At <10 people the person who holds taste and code is the whole design function.
Series A/B teams run senior-only design pods. The ladder has a top and a middle, no bottom.
Figma + Make → Cursor → internal agent orchestration
One person, full stack, ships everything
v0 → Cursor → Figma Make
Vibe-coding closed the gap between design and production; the founder's designer has to live in both or they're half useful.
First real design team, already fighting agent sprawl
Figma → Cursor → v0
Founding designer ships code, not Figma files
Cursor → v0 → Figma
At seed stage, the handoff is dead — one person who designs and ships code is worth three who don't.
First design system agents can actually read
Figma → Storybook → Cursor
Build your own tools, ship your own brand
Cursor → v0 → Figma
Vibe-coding has eaten the handoff — one person who designs and builds moves faster than a two-person team at this stage.
First design system, first design ops hire
Figma → v0 → Maze
One person, full stack, ships in a week
v0 → Cursor → Figma
When v0 and Cursor eat the handoff, the designer who can also ship code owns the whole product loop at a seed company.
First design system, agent-readable from the start
Figma → Figma AI → v0
One person, full stack, ships this week
v0 → Cursor → Figma
Builds and ships alone — prototype, product, and brand without waiting for anyone.
First design hires own the system and the agent
Figma → v0 → Cursor
One generalist, one retainer, full stack
Figma → Framer → Midjourney
Vibe-coding eats the handoff — this role ships design and implementation in the same sitting.
First real team, first real system fight
Figma → v0 → Framer
Vibe-code the brand, own the judgment layer
Figma → v0 → Midjourney
At seed stage, the designer who can prompt-to-production without a handoff compresses the roadmap by weeks and owns both taste and velocity.
First design system, first real governance debate
Figma → Figma Make → Maze
One prompt, full brand kit, ship tomorrow
Canva AI 2.0 → Claude Design → Framer
Vibe-coding via Claude Design collapses the design-to-code handoff, making hybrid builder-designers the highest-leverage single hire at seed stage.
Design system becomes agent rulebook
Figma (with Agent Canvas / Skills) → Claude Code → Canva AI 2.0
One generalist, agent co-pilot, zero art department
Figma → Midjourney → ChatGPT
Vibe-coding tools collapsed the handoff, so the most valuable hire codes and designs from the same prompt.
First design system, agent-accelerated, brand rules required
Figma → Adobe Firefly → Framer
Frames-to-PR: founders ship design without handoff
Figma → v0 → Cursor
Vibe-coding tools eat the handoff entirely at seed scale, so the person who designs and ships the branch in the same session is the only design hire that makes sense.
First design system, AI-augmented from day one
Figma → Storybook → v0
Vibe-code your MVP, skip the handoff
v0 → Lovable → Figma
At seed stage, shipping a working product matters more than a polished Figma file; vibe-coding makes a designer who can deploy the single most valuable hire.
First design system, now it ships real code
Figma → Figma Make → v0
At Series A-B the CD sets direction for both the agent fleet and the humans learning taste. It's the only role that scales both ways.
Large companies run small human design teams on top of heavy agent infrastructure. The rebuilt entry-level program is a formal apprenticeship.
Figma enterprise → internal agent platforms → Cursor/Claude Code
Large orgs need a human taste layer that can direct both machines and people. That role sits above the agent stack and owns the output.
The person who can write the code and hold the taste is the single most valuable hire at this stage. They collapse two roles and remove a handoff.
Enterprise design orgs rebuild the bottom rung on purpose — apprenticeships, residencies, and taste training replace the old junior pipeline.
Figma enterprise → internal model gateways → custom evals for brand and product taste
At scale, the job is keeping a point of view consistent across thousands of agent-generated surfaces. That is a director's job, and it is the one role every large org is actively hiring for.
Scaler stage is where the taste bottleneck bites hardest. One person has to hold the line across a lot of agent output.
Enterprises formalize agent governance inside design orgs and launch structured junior programs to rebuild the pipeline they broke.
Figma enterprise → internal model partnerships → agent governance tooling
At titan scale the role becomes a function, not a person — but the title sticks and the mandate hardens.
At scale-up, the bottleneck is no longer execution capacity. It's coherent direction across many agent-driven surfaces. Design Engineers close that gap faster than a traditional designer-plus-engineer handoff.
Enterprises formalize the AI Creative Director role and build internal governance around agent output. The stop button becomes a design discipline.
Figma enterprise agent suites → internal model routing → governance and review tooling
At enterprise scale, the risk is agents shipping confident garbage at volume. The AI Creative Director holds the taste line and the guardrails. That role gets a budget and a title by Q2 2027.
Someone has to hold the point of view across every agent output. That's the job.
Enterprises formalize agent governance in design. Stop buttons, refusal patterns, and audit trails become design system components.
Figma enterprise → internal agent platforms → design-system AI readiness tooling
Big orgs are shipping agents into regulated surfaces. The restraint layer is the design job.
At this stage the system is what keeps agent output coherent; the person who owns that system owns every screen the company ships.
Design governance is now a product requirement
Figma → Figma Make → Storybook
At scale, taste and judgment applied to machine output is the lever — the director who can steer agent work across an org is worth more than any single executor.
At Scaler stage, the design system is now infrastructure for AI agents — whoever owns it owns the product's coherence.
Design governance becomes product strategy
Figma Enterprise → Storybook → Runway
At Titan scale, dozens of agents ship design daily — the Creative Director sets the taste standard every agent is measured against.
Scaling teams need rules — who owns the system and its AI-generated variants determines whether quality holds across a growing org.
Agentic guardrails become a design deliverable
Figma → Storybook → Adobe Firefly
At scale, the constraint is taste and governance — someone with authority over what the machine ships and why is the highest-value seat in a large design org.
Scalers are building the foundation everything else runs on — and that foundation now has to work for AI agents and human eyes at the same time.
Design ops governs what the agents ship
Figma Enterprise → Adobe Firefly → Runway
When AI agents generate at scale, someone has to own the rules for what ships — and that's a design ops job, not a staff designer's side task.
Owns the rules that keep AI output on-brand as the team scales and agent usage grows.
Design governance becomes the real product
Figma Enterprise → Cursor → Playwright
Sets taste constraints that govern what hundreds of AI-generated outputs are allowed to become.
AI-generated components are arriving from non-designers — someone has to decide what ships and what doesn't.
Design org as editorial board, not factory
Figma → Adobe Creative Cloud → Runway
Synthesis beats execution at enterprise scale — this role turns a flood of AI output into a coherent brand position.
At Series A–C velocity, a coherent design system is the only thing preventing AI-accelerated teams from producing inconsistent product experiences at scale.
Design-system AI gets enterprise governance
Figma (Enterprise) → Adobe Creative Cloud → Runway
At Titan scale, the synthesis of strategy, narrative, and system-level coherence beats execution speed — AI handles production, humans set the story.
Figma's Agent Canvas makes your component library the grammar agents speak — whoever maintains that grammar controls every screen the agent ships.
Agent governance is the new design ops
Figma Enterprise (Skills + Agent Canvas) → Adobe Firefly for Enterprise → Canva Enterprise AI 2.0
At scale, the risk isn't under-production — it's off-brand agent output at volume; the CD role owns the taste layer and liability for every agent-generated asset.
Agents need rails — this role writes them, making every downstream AI output on-brand by default.
Agent governance is the new brand governance
Adobe Creative Cloud → Adobe Firefly → Figma
At scale, agents produce fast; the brand storyteller decides what the brand should actually say — synthesis beats execution.
Scalers need the person who owns the design-system-to-code bridge—without them the Codex integration creates token chaos rather than velocity.
Design-system AI gets enterprise governance
Figma → Adobe Firefly → Runway
At Titan scale, AI handles execution volume; the role gaining leverage is the one synthesizing brand narrative into the prompts, tokens, and guardrails that govern all of it.
At scaler stage, a well-structured design system is the prompt infrastructure that keeps AI-generated components coherent as the team ships faster.
Governance layer arrives for AI-generated brand output
Figma → Adobe Firefly → Adobe Acrobat Studio
Mature orgs have no shortage of generated output; they need someone with taste and authority to decide what gets approved and shipped at scale.