My team ships AB tests constantly. At some point, the codebase started turning into a graveyard of feature flags, dead conditional logic, and TODO comments (or the lack thereof) about cleaning up old experiments. The breaking point: a major component with 4 experiments - hundreds of lines, where changing one thing risked breaking another (which it did). That's when I discovered that custom hooks could be more than reusable logic - they could be containers for isolating experimental code.
Through this talk, I’ll share my experience of using hooks as boundaries for implementing experiments, and how this pattern has improved the way my team can ship features fast while keeping technical debt in check.

Modern JavaScript applications often pass automated accessibility checks with flying colors. Tools like Lighthouse, Axe, and CI pipelines give us green reports, and we feel confident shipping.

But what happens when real users interact with the application?
In this talk, we’ll explore why automated accessibility testing only catches a fraction of real issues. Through a live demo of a seemingly “accessible” JavaScript form (we will see on the Lighthouse and Axe DevTool no accessibility issues), we’ll uncover hidden problems that automated tools completely miss, such as broken keyboard navigation, silent dynamic UI updates, and modal dialogs that behave correctly visually but fail real users.

You’ll learn why accessibility is not just about passing automated checks, but about understanding how people actually interact with your JavaScript applications.

This session will include a live demo, practical examples, and concrete takeaways developers can apply immediately.

Most teams hear "AI design system" and reach for the thing they already know: a component library, now with a chat panel bolted onto it. I think that's the wrong shape. A design system in an AI-assisted codebase isn't a catalogue of components; it's a set of architectural contracts that a coding agent can actually be held to. Tokens, composition rules, and constraints that are legible to a model, not just to a designer in Figma.

The talk walks through what that looks like in practice: what an agent gets wrong when your system is only documented in prose, how to encode intent so the generated code is boringly consistent instead of plausibly wrong, and where the boundary sits between what you let a model generate and what you pin down by hand.

What attendees can expect to take away:

It's aimed at frontend and product engineers, and at design-system maintainers wondering what to do about all this. No prior AI-tooling experience needed.

Developers find themselves in a world where old maps no longer apply. The rules of software development have fundamentally shifted, and continue shifting at unprecedented speeds.

Drawing from a year of exploration, this talk reveals where AI truly shines - from rapid prototyping to uncovering what we didn't know we didn't know - and hidden dangers that can erode the very trust our software depends on.

Come discover the patterns emerging from this new reality: when to explore freely, when to be careful, and what opens up when the old constraints disappear.