AI is evolving too fast.
I needed to take a step back and regain clarity on how it affects my work and thought.
The process: 2 layers
My process with AI centers around 2 layers:
L1 = Design Architecture. This is the jam session before execution. Working with AI to crystallize the crux of the problem: the why, design principles, constraints, what success looks like, user + biz context. Utilise AI to deepen understanding of problem and solution. Win win. I thoroughly articulate thinking while AI captures all that as context.
L2 = Contextual Execution. AI starts to cook, but with grounded truths. It retrieves context from L1, executes, evaluates its own work, stress-test against constraints, iterates, and presents thorough options with trade-offs.
Importance of clarity
Models are getting insanely smart. And that makes grounded understanding more critical than ever, not less.
ie) Opus 4.6 can spin up a planning agent with its own team of ICs, agents that reason, argue, and pressure-test ideas amongst themselves before anything surfaces to us (wtf!). No more single agent sequentially working through approaches. We get the product of 3 independent minds, forming richer options. More angles considered.
But the catch: shitty prompts no longer yield obviously shitty results.
The model fills gaps with substance that feels “just alright.” Every ungrounded decision and understanding compounds into artifacts with no anchor. Cognitive debt builds. Users get confused. You’ve built something you don’t fully understand. How it works now? How should it evolve? An unopinionated product with no cohesion; aka slop.
Until AI is able to read our minds and decompose our implicit intuition, empathy, and taste into legible constraints without frying it’s context window; we must arm our systems with strong design principles that are scalable across projects.
Unfortunately… I don’t have a playbook or answer to this. It’s a matter of a lot of testing and tweaking.
It’s interesting to think about the Minimum Viable Context needed to ensure our system follows grounded principles.
How do we distribute hard-coded design philosophies vs. instructions for AI to reference existing design patterns vs. pulling user interviews / usage data from posthog vs. ingesting our full business manifesto? How can we chunk them and have the system pull the right info at the right time without overwhelming the context window?
Execution and the feedback loop
In L2 / execution, my current flow looks like this:
Jam session with AI to deeply understand the problem → create plan → let them cook → present options → test & experiment with each variation → branchThe branch is either:
Path A = Direct feedback to AI. AI takes the feedback, anchors back to L1, and executes again. The cycle keeps going, reasoning chain and context is intact.
Path B = Go to figma and self cook. Iterate at speed, from visual tweaks to fundamental UX decisions. But when returning with the artifact, AI only sees the end result; not the 50 micro-decisions that amounted. MCPs can ingest every pixel but it simply can’t reverse engineer the reasoning, the euphoric string of decisions I made in flow. Context leaks, chain breaks.
The black box creates confusion. AI fixates on things that don’t matter, fills gaps with its own logic, misses the thinking that was actually exercised. Momentum dies. You catch AI up, inevitably miss a few decisions, course correct, repeat.
The tension
Figma isn’t the bottleneck, it remains essential. When I jump to Figma, I’m exercising craft. Translating intangible ideas and taste onto an empty canvas with speed and precision. The freedom is crucial. Output, iteration, output, iteration — without having to wait or correct a nit that doesn’t look to exactly what I imagined. Stacks of decisions with no lag. No need to pause or articulate why. Pure creation and flow… beautiful.
This is what gives what we’re building life.
But that flow comes at a cost: context and reasoning don’t make it back to AI. So… how can we create an interface to bridge the gap between Path A and B? How can you allow a designer to go into flow state while their motions, decisions, and reasoning are being captured for full context?
Cursor is trying to do this with design mode, but it’s rudimentary. Lag to implementation remains. Could this take form as an infinite canvas?
Building for myself
I, again, don’t have answers for my previous question.
Adjacently, though, I’ve been building my own internal tool at work to manage projects, versioning within projects, and exploration branches within versions. The main work area contains the artifact editor, versioning with reasoning, an exploration panel for generating style variations and swapping them into the existing artifact. Until the right UX is discovered, designers have the power to build our own tools that suit how we think and work.
Takeaway
Admittedly, I went a bit overboard trying to productionise my entire job lmao. Taking a step back, it’s easy to get caught up being overly impressed by AI’s capabilities. What I’ve learned from this reflection isn’t the upside — it’s the cascading damage of using AI without precision. In moments when we’re lazy, rushed to ship. Slop compounds. Debt accrues exponentially.
I’m committed to building a system that accounts for these moments.
Until AI can learn our intuition, the craft remain ours. So does the responsibility not to let shit rot.
Osmond Wu