Episode Details

Our latest episode explores the moment AI stops being a tool and starts becoming an organizational model. Agentic systems are already redefining how work, design, and decision‑making happen, forcing leaders to abandon deterministic logic for probabilistic, adaptive systems.

“Agentic systems force a mindshift—from scripts and taxonomies to semantics, intent, and action.”

🎧 Listen on Spotify🍎 Listen on Apple Podcasts

And if you want to go deeper, check out Kwame Nyanning’s book, Agentics: The Design of Agents and Their Impact on Innovation. It’s the definitive field guide to designing agentic systems that actually work.

Most striking for me was when discussed that we need to move from pixel-perfect to outcome-obsessed. Designers and product teams have for so long been more obsessed on the delivery of the output and now is time to be most concerned on the impact on customers.

The hard truth: Most organizations are trying to graft AI onto brittle systems built for predictability. Agentic design demands something deeper: ontological redesign, defining entities, relationships, and intents around customer outcomes, not internal structures. If you can’t model intent, you can’t build an agent.

Key takeaway: Intent capture is the new UX. Products that succeed will anticipate user context, detect discontent, and adapt autonomously.

Featured Articles: Where Reality Collides with Ambition

AI Has Flipped Software Development — Luke Wroblewski

Wroblewski lays out how AI has upended the software stack. Interfaces now generate code. Designers define the logic while engineers review and govern it. The result? Faster cycles but a dangerous illusion of progress. Design intuition becomes the new compiler, and prompt literacy replaces syntax. The real risk is velocity without comprehension; teams ship faster but learn slower.

Takeaway: Speed isn’t the problem; blind acceleration is. Governance, evaluation, and feedback loops are now design disciplines.

Agentic Workflows Explained — The Department of Product

This piece exposes what it really takes to build functioning agents: memory, planning, orchestration, cost control, fallback logic. If your “agent” doesn’t break, it’s probably not learning. Resilient systems require distributed cognition, agents reasoning and retrying within boundaries. Evaluation‑first design becomes the only safeguard against chaos.

Takeaway: If your agent never fails visibly, it’s not thinking deeply enough. Failure is how agents learn.

Featured Videos: Cutting Through the Noise

This viral video sells the dream—agents at the click of a button. The reality? Building bots has never been easier, but building agents remains brutally hard. Real agents need long‑term memory, adaptive interfaces, and feedback loops that learn from success and failure. Wiring APIs is not design; it’s plumbing. Until agents can reason, reflect, and recover, they’re glorified scripts.

Reality check: The tools are improving, but the discipline is not.

A rare honest take. This one focuses on the HCI,