AI Engineer World's Fair 2026
How to Get Your Org to Adopt Coding Agents (Without Shipping Garbage) — Eyal Blum, Figma
Loading slides…
Read the talk
How to Get Your Org to Adopt Coding Agents (Without Shipping Garbage)
Eyal Blum explains Figma’s still-evolving approach: turn recurring failures into verification, give engineers substantial planning work to own, and treat skeptical reviewers and scarce human attention as design constraints.
From a talk by Eyal Blum
At a glance
Ideas worth remembering
Early coding-agent wins do not generalize automatically. Dependable adoption begins after larger tasks expose missing context, guardrails, and verification.
Turn recurring agent checks into deterministic tests, establish verification criteria before implementation, and reserve human review for functionality, intent, and product judgment.
A plan should preserve a stable purpose, divide work into reviewable phases, and validate each phase before later work depends on it.
Experienced skeptics often carry the codebase knowledge that agent workflows lack. Give them ownership of the safeguard roadmap instead of treating resistance as a persuasion problem.
Protect reader attention by placing a concise human-written explanation before clearly distinguished generated detail, and state what expert judgment you need from the recipient.
Adoption can begin inside familiar workflows such as Slack, but incomplete automation and build-system dependencies remain real constraints.
Adoption starts fast, fails hard, then becomes engineering
This is a talk about Figma’s internal engineering organization, not its product. The problem is how teams can adopt coding agents without lowering the quality of an established codebase. Blum’s starting model has three acts: simple tasks produce an apparent “10x faster” moment; the same techniques fail on larger work, creating bugs and breaking trust; then users learn the harder discipline of supplying context, guardrails, verification, and better instructions.
Teams do not move through those acts together. Some at Figma have already changed their workflows around agents, while others are still experimenting or recovering from bad results. They nevertheless contribute to the same product. Adoption therefore cannot depend on an organization-wide leap of faith; teams at different levels of confidence must coexist while the organization improves the conditions under which agents can work reliably.
The three acts of coding-agent adoption
Read the diagram as text
- Simple-task success. Initial experiments can appear dramatically faster.
- Larger-task failure. Bugs and poor output break the trust earned by early wins.
- Engineered adoption. Context, prompting, guardrails, and verification become learned skills.
- Simple-task success → Larger-task failure: Apply the same practice to bigger work.
- Larger-task failure → Engineered adoption: Respond to failure with safeguards.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The costs arrive before the safeguards
The first cost is reduced developer agency. Engineers who enjoyed writing code and entering a state of flow can end up in a prompt-and-wait cycle: ask the agent, wait for output, inspect it, and ask again. Blum reports lower job satisfaction and possible burnout. Faster implementation does not automatically make the work more rewarding for the person directing it.
The second cost lands on the engineers who understand the codebase best. They know its undocumented assumptions and recognize where generated changes can fail. That institutional context acts as “mental duct tape”: they stop bad changes, absorb more review work, become bottlenecks, and grow frustrated. In Blum’s account, the strongest engineers may adopt agents last because they encounter the risks first.
The third cost is attention. Blum describes design documents, Slack messages, and emails becoming three or four times longer, while email volume grows two or three times, without a comparable increase in substance. Readers must work harder to identify what matters and what deserves trust. These are observations from an unfinished transition: Figma has seen progress, but Blum explicitly says the organization has not reached the other side.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Move verification down the stack before generating more code
Blum calls verification the highest-value investment a team can make in its codebase. The immediate move is to shift checks away from manual exploration and toward tools an agent can use itself. He cites Playwright with MCP as an example: giving an agent a way to explore an application reduced work that previously required a person and unlocked productivity for several teams. The important mechanism is closed-loop work—the agent can inspect the environment and gather evidence before asking for review.
Agent reasoning should not remain the permanent implementation of a check. When an agent discovers a useful, repeatable test, encode it as deterministic automation. That saves time and tokens, makes results reproducible, and reserves the language model for questions that still require judgment. The progression is: use the agent to discover what needs checking, then turn known checks into ordinary software.
Test order matters too. Blum recommends a red-to-green TDD cycle: establish a failing test and then ask the agent to implement code that passes it. If the agent writes the implementation first and the test afterward, it can fit the test to what it already produced. Test-first work instead fixes the verification target before implementation begins. Blum reports that this usually improves results, though it does not guarantee that either the test or the implementation is correct.
The resulting review pyramid has three layers:
- Deterministic checks: Linters, compiler checks, and unit tests cover conditions software can decide directly.
- Agent review: Explicit criteria can cover encoded architectural standards and other checks that need some reasoning.
- Human judgment: People concentrate on functionality, intent, and whether the change is the right thing to build.
The goal is not to remove human review. It is to stop spending scarce human judgment on checks that machines can perform consistently.
A review pyramid for agent-generated changes
Read the diagram as text
- Human judgment. top — Assess functionality, intent, and whether the change should exist.
- Agent review against criteria. middle — Check architectural standards and other encoded expectations.
- Deterministic analysis. base — Run linters, compiler checks, and unit tests.
- Deterministic analysis → Agent review against criteria: Escalate what fixed checks cannot decide.
- Agent review against criteria → Human judgment: Reserve final judgment for people.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Plans give engineers decisions to own
Planning addresses both reliability and the loss of developer agency. Rather than spending the day reacting to generated code, engineers can own the decisions: what to build, why it matters, how the work should be divided, and how each part will be checked. Blum says it is not unusual to spend a week writing and revising a detailed plan, resolving choices, and getting teammate review before an agent begins implementation. That preserves deliberate engineering work while moving mechanical execution to the agent.
A useful plan begins with a stable explanation of why the work exists. Blum recommends a prominent executive summary that the agent can revisit when it starts to drift—and that the agent should not casually rewrite. The plan then breaks the work into small phases that can each be verified independently.
His sizing heuristic is deliberately human: would he want to review the corresponding pull request in one sitting? If a reviewer feels they need to fetch coffee before opening it, the phase is too large. This matters because an agent’s ability to generate a large diff does not increase a reviewer’s ability to understand it.
Every phase also needs a validation gate or explicit exit criteria. Otherwise, a five-stage plan can complete its first stage without checking it and build four more stages on a faulty assumption. Independent validation prevents an early mistake from becoming the foundation of later work. Once this structure exists, teams can choose their preferred agent loop; Blum sees diminishing returns in forcing everyone onto one centralized workflow, provided collaborators can still inspect and iterate on the work.
Blum illustrates the approach with roughly 20 pull requests, some around 10 lines and others around 100, with probably nothing larger. He describes about a week of planning, another week aligning with three teams, and an overnight agent implementation. He then estimates that roughly six weeks of coding work took one week and calls the result a 5x speedup after accounting for review. He also says the example probably came from two plans, so the spoken timeline should be treated as an approximate project account rather than a controlled productivity measurement. The durable lesson is simpler: implementation speed only counts if the resulting changes remain small enough to review, and review time belongs in the calculation.
From a stable plan to reviewable implementation
Read the diagram as text
- Stable purpose. An executive summary explains why the work exists and anchors later decisions.
- Small implementation phase. Sized to become a pull request a person can review in one sitting.
- Independent validation gate. Checks the phase before dependent work proceeds.
- Next phase or subagent. Receives detailed, validated work rather than an unchecked assumption.
- Small pull requests and review. Human review remains part of the speed calculation.
- Stable purpose → Small implementation phase: Constrains implementation.
- Small implementation phase → Independent validation gate: Verify before continuing.
- Independent validation gate → Next phase or subagent: Proceed only after validation.
- Next phase or subagent → Small pull requests and review: Produce bounded changes.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Treat skeptics as the safety roadmap
Blum returns to the experienced engineers carrying the largest review burden. Their objections identify missing validation, undocumented assumptions, and places where agent tooling fails. Trying to persuade them to use AI misses the information inside their resistance. Their complaints are a roadmap for making agent interaction with the codebase safer.
His organizational recommendation is to give those engineers ownership of that roadmap. As they encode safeguards and remove recurring failures, their own review burden should fall; adoption can follow from seeing the system improve rather than from an executive mandate. Blum notes that less than an hour of brainstorming with a group produced a substantial list of fixes, suggesting that the missing-safeguard backlog may already be sitting in reviewers’ heads.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Generated communication needs an attention budget
Once generation makes text cheap, reader attention becomes the constrained resource. Blum’s team uses a simple convention to help allocate it: distinguish what a human wrote from what AI generated. The distinction tells readers where the author has exercised direct judgment and where they should expect more uncertainty or noise. Blum presents this as a team practice being considered more broadly, not as an organization-wide Figma rule.
Every pull-request description on his team begins with a short human-written explanation of what the change does. Generated detail follows below. The author may read and edit that material, but did not personally write every line, so readers should give the opening explanation greater weight and scrutinize the generated section more carefully. The same convention can apply to Slack and email: disclose the generated portion and tell people where to focus.
The practice came from a failed interaction. Blum used AI to analyze comments from skeptical senior engineers, then sent the analysis without clearly separating his contribution from the generated text. They regarded the result as unexpectedly sloppy. His correction was not merely to add an AI label; he also needed to state his intent. He lacked enough context to judge the analysis and wanted their expert feedback. That framing would have told recipients both what was uncertain and what work he was asking them to do. For Blum, changing communication culture is as important as solving the engineering problems.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Let people meet agents inside familiar work
Blum’s final tactic is intentionally less sophisticated than a software factory: put agents where people already work. In a Slack conversation, someone can tag an agent, ask it to perform a task, and have it return the result in the same thread. That removes the setup cost of learning a separate interface and turns adoption into a shared, concrete experience.
The social delivery matters. With a colleague who is not convinced, Blum suggests trying the agent together without making the gesture passive-aggressive. If the agent closes the loop successfully, that result can encourage the colleague to try it independently elsewhere. More elaborate automation can come later; the first useful experience should happen inside an existing workflow.
The talk ends with limits still visible. Figma continues to experiment, its automation is incomplete, and dependencies in parts of its build system still complicate effective use of cloud agents. Shipping external AI features has not made internal adoption a solved problem. Blum describes the transition as both cultural and technical—and, after 15 years working in the Valley, as the largest change he has seen by orders of magnitude. His recommendations are therefore working practices from an organization still learning, not a finished operating model.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
The official AI Engineer page with the recording, timestamped transcript, chapters, and reading version.
Related talks
- Making Codebases "Agent-Ready"
Extends Blum’s verification argument with concrete codebase-readiness measures such as opinionated linters, tests, documented interfaces, and continuous validation.
- No Vibes Allowed: Solving Hard Problems in Complex Codebases
Develops the research-plan-implement workflow for established codebases where undocumented context and rework make agent use difficult.
- Your Attention Is the Bottleneck, Not Your Agents — Zack Proser, WorkOS
Explores the same scarce-attention constraint through layered verification, background agent work, and developer well-being.
Full transcript
Loading transcript…