Talks

Design systems often start with good intentions consistency, efficiency, scalability. But in practice, they frequently become blockers, overly rigid, or out of sync with product demands.

This talk shares how we approached building a system that adapts as fast as our products do. Instead of fighting change, we embraced versioning, modularity, and progressive adoption.

I’ll also cover how we introduced lightweight governance without creating bureaucracy. With clear boundaries and thoughtful defaults, even small teams can move fast without reinventing patterns.

Whether you're starting fresh or refactoring an old system, this talk will give you real-world tactics that work under pressure.

Creating a reusable UI library is easy. Maintaining it as multiple teams ship features at different speeds that’s the real challenge.

We started with a mono-repo and a dream. Over time, we learned how to balance reuse with autonomy, how to say no to unnecessary abstractions, and how to communicate change clearly across teams.

I’ll walk through our approach to API design, docs-first development, and how we tested components across different product shells.

You’ll leave with strategies to scale your component library without drowning in breaking changes, edge cases, or developer complaints.

This talk is ideal for teams transitioning from copy-paste components to something more durable and centralized.

Many developers love Tailwind, but struggle to organize it beyond prototypes. This talk breaks down how I turn Tailwind UIs into premium templates that are consistent, scalable, and production-ready.

I'll share the structure I use for layers, design tokens, and component boundaries and how I prepare my projects for resale or reuse.

We’ll look at common pitfalls like config bloat, naming chaos, and inconsistent spacing. I’ll also demo how I build theme support into every template from day one.

Finally, I’ll explain the monetization side licensing, packaging, and what makes a template worth buying versus just cloning from GitHub.

We’re entering a new era of UI development one where you don’t build everything yourself, you import from a registry.

This talk explores what that future looks like, and how it changes our tooling, workflows, and collaboration.

I’ll walk through the architecture behind our own registry, powered by Effect and a CLI-first interface. It supports aliases, diffs, and overrides making it feel like a native part of your repo, not an external dependency.

We’ll talk about how this approach compares to npm packages, monorepos, and copy-paste libraries and why we think registries are the next evolution.

Expect technical deep dives, tradeoffs, and the real-world chaos of keeping 40+ components in sync across 10+ projects.

Selling UI templates sounds easy until you try. This talk is a brutally honest look at what it takes to ship and sell templates that people actually want.

From concept to launch, I’ll explain how I design, validate, and build templates with Tailwind and React. Every detail from class naming to accessibility matters when you're selling.

We’ll cover the business side too: pricing, licensing, support, and how to handle updates without burning out.

I’ll also share marketing insights: how I position templates, write landing pages, and build trust with developers who’ve been burned by junk before.

If you want to stop freelancing and start earning from your own products, this is your blueprint.

This talk is about speed but not the kind that breaks things. We’ll explore how to ship quickly while keeping user experience sharp, intentional, and unbroken.

I’ll walk you through the UX guardrails we use on every project: interaction minimums, fallback defaults, and state clarity. We test for breakage not just in code, but in perception.

You’ll see how we handle design debt proactively, and how we’ve built confidence into our release pipeline.

This isn’t about perfection. It’s about velocity without regret.

Good tooling changes everything. In this session, I’ll share how we improved our DX by building tools that feel like magic.

We’ll look at CLI generators, schema-first config files, and runtime validation with Effect. Our goal was simple: fewer bugs, faster onboarding, and happier developers.

I’ll show how we eliminated 80% of manual setup time and made consistent project structure a default, not an afterthought.

This talk is especially for indie builders and teams tired of boilerplate and ready to ship with flow.

When a component library is small, it feels like a cheat code. But when teams grow and products diverge, that same library can become a war zone.

I’ll talk about how we built Intent UI not just technically, but culturally. How we enforced standards without becoming a bottleneck. How we tracked usage without spying.

We’ll dive into lint rules, changelogs, contribution workflows, and the dreaded breaking change policy.

If you’ve ever tried to keep a design system alive across multiple teams, this is the talk that understands your pain and gives you a way forward.

Minimal UI isn’t about removing features it’s about removing friction. In this talk, I break down the design philosophy behind minimalist interfaces.

We’ll cover visual hierarchy, spatial rhythm, and how to use motion without distraction. I’ll also walk through how I design forms, dashboards, and modals that feel invisible until you need them.

I’ll share examples from Intent UI and my templates how I made them clean, fast, and purposeful.

This talk is for designers and developers who care more about clarity than flair.

Effect is underrated for CLI tools. With its strong types and built-in resource handling, you can build stable, expressive tools with less boilerplate.

This talk shows how I built the @intentui/cli from scratch. I’ll cover schema parsing, command routing, HTTP requests, and error formatting all powered by Effect.

We’ll also look at testing strategies, config resolution, and how we ship tiny utilities that feel native inside any project.

If you want to write tools that don’t suck and that scale as your system grows this talk is for you.

Bonus: I’ll show how to turn your Effect CLI into a registry interface with add, diff, and overwrite support.