Engineering brief
Why agentic design still needs the human sketch
At a glance
The brief is enough
- Relevance
- Practical value
- Radar
- Time horizon
- This year
- Warnings
- None
Maggie Appleton shows why agents can't replace design: they lack taste, spatial reasoning, and team alignment. The real bottleneck is not model capability but how teams agree on intent before handing off to agents.
Agents won't replace design; they shift the bottleneck to team alignment and upfront specification.
Watch if you want to see a live demo of agent-assisted design prototyping and how jigs work in practice.
Summary
The core idea. Maggie Appleton, a design engineer at GitHub Next, argues that the most valuable design work happens before any code is written—in sketches, notebooks, and live prototypes. Agents can speed up implementation, but they cannot replace the human process of understanding materials, constraints, and context. The real bottleneck is not model capability but workflow design and team alignment.
Why this matters now. As agents become competent at generating UI code, engineers are tempted to bypass designers entirely. Appleton warns that agent-generated design is easy to spot and lacks cultural nuance. Design is part fashion, part function; agents trained on current aesthetics will produce forgettable, generic interfaces. Teams that rely on agents for design risk losing differentiation.
The tension. Appleton shows a live demo of a "jig"—a set of sliders and knobs built by an agent that lets her tweak animation variables in real time. This is faster than static Figma mockups and closer to the principle of "live programming." But she admits the agent cannot yet match her taste. She still ends up manually adjusting padding and colors, suggesting the craft gap is real and may persist.
The missing piece. The biggest gap in current agent tools is multiplayer collaboration. Every agent session is private and local. Teams cannot align on decisions before handing off to agents. Appleton prototypes a decision-centered interface where each choice gets its own card, assigned to a human, with diagrams and context. This is the unsolved problem: how to make agents work in teams, not just for individuals.
What most will miss. The talk surfaces a subtle trade-off: as agents make implementation cheap, the upfront alignment work becomes more expensive. Teams must agree on design and architecture before agents start coding, because rapid iteration no longer exists. This shifts the skill set needed from "writing code fast" to "specifying intent precisely." Engineering leaders should invest in decision-making tools and shared context, not just more agentic harnesses.
The bottom line. Appleton’s experience suggests that agents are a productivity amplifier, not a replacement for design thinking. The hardest problems—team coordination, taste, and user understanding—remain human. The hype around agents replacing designers is overblown; the real opportunity is to use agents as coaches and rapid prototypers while keeping humans in the loop for judgment.
My take
I agree with Appleton that the hardest part of agentic design is not the agent but the team alignment. The demo of the jig is compelling, live variables make design exploration far more fluid. But I'm skeptical that most teams have the discipline to spec intent as precisely as she describes. The real risk is that engineers will use agents to ship bad UI fast, then declare design unnecessary. That's a organizational failure, not a tooling one. Leaders should set standards for when agent-generated UI goes to production, just as they do for code review. The digital garden idea also resonates: publishing half-baked thoughts is a good antidote to perfectionism, but it requires a culture that values iteration over polish.
What to do with this
- Ask your team to sketch a UI by hand before opening any agent tool, see if it changes their design decisions.
- Run a pilot where designers and engineers pair on agent-generated prototypes with live variable sliders.
- Assess whether your current planning process captures decisions with enough context to feed to agents later.
Watch the video
This video is blocked due to your privacy settings. To watch this video, please accept YouTube marketing cookies.
Related breakdowns
The 12 months that rewrote the rules of software engineering
AI-generated code is now the norm, IDEs are legacy, and code reviews are broken. Engineering leaders are exiting. The CPU shortage is here.
AI code generation is cheap. Validation is the new bottleneck.
The real AI bottleneck isn't generating code but validating it when no human reads it. Teams must build trust through testing and observability.
Dark AI Factories Break: Context Engineering and Slow Loops Work
Dex Horthy explains why his lights-off coding factory failed and how context engineering plus incremental loops are the pragmatic path to reliable AI code.
Get TL;DW
Too Long; Didn't Watch.
A concise breakdowns of the AI and devtools videos that actually matter for engineering leaders.
Free. Weekly. No hype.
Video and thumbnails remain the property of their respective creators. tldw.news provides editorial analysis, commentary, and discovery links to original content.