The easiest thing to do is often what causes hours of debugging down the line. With LLMs becoming increasingly normalized in the industry, an overreliance on them can allow bugs to slip through the cracks.

In this talk, I'll demonstrate a practical debugging workflow: Debug first. Prompt second. I'll show how browser DevTools reveal what's actually happening faster than any AI can guess.

You'll learn:

• Essential DevTools features that improve your bug-fixing prowess
• When to reach for your browser and when AI can actually help
• The almost forgotten art of breakpoints and strategic console messages

AI in your codebase represents growth, but understanding your runtime state represents mastery. This talk is about balancing both and knowing which tool to reach for first.

Have you ever explored how React works under the hood, in its source code? As a Senior Frontend Developer specializing in React, surprisingly, I hadn't until this year, when I decided to make it a priority.

Spoiler alert - it's not easy! The React and React-DOM bundles that come in the npm packages don't expose source maps, and certain transformations make the code hard to read. So I decided to figure out how I could bundle the source code myself to facilitate following along in a few courses I found on React internals. This talk presents that process and the pretty-good but still work-in-progress outcome.

Thanks to AI, designers and PMs are now prototyping and deploying faster than ever, sometimes without writing a single line of code. Tools like Lovable, Bolt and others can generate entire applications directly from prompts, while design tools are blurring the lines between mockups and implementation. So where does that leave React engineers?

As AI tools become UI builders, one trend is clear: React is becoming their default output. It's quickly turning into the universal framework of AI, putting React developers at risk of seeing their core skills commoditized.

In a world where AI can generate impressive UIs and ship entire components from a single prompt, it's tempting to declare the death of frontend engineering.

But what if we're just looking at it wrong?

The pixel-pushing days may be over, but the complexity is just shifting layers. Welcome to the age of the back of the frontend. This talk explores how AI is fragmenting the frontend into fast, flashy outputs and deeply nuanced logic, and why the real value now lies beneath the surface.

We'll break down what's actually being automated (spoiler: it's not the hard stuff), the logic, flows, edge cases, performance, that's still on us. We'll examine where human acuity still matters, why knowing when not to use AI might be your new superpower, and how the integration of AI-generated React components into complex, multi-framework applications creates new engineering challenges.

This talk doesn't shy away from the uncomfortable question: what is your job when everyone can "build"?

If you're a frontend dev wondering whether you still have a job, you do. But it may not look the same as the one you trained for. The new frontier isn't just building components, but designing the systems that allow AI-generated components to function in the beautiful complexity of production applications.

What happens when you need to refactor 377 files in a SvelteKit codebase? Without AI, you retire. With Claude Code, you ship it in 11 hours.

This talk walks through real-world examples of using Claude Code for massive refactoring work that would be soul-crushing to do manually. I'll cover:

• How I approach large-scale refactors with Claude (377 files → 364 files → and counting)

• Building and activating Claude Code skills reliably (based on my viral post that's getting 4k+ views in 3 days)

• The workflow patterns that actually work vs the ones that waste your time

• Real examples from production codebases

This isn't about AI replacing developers - it's about using AI to handle the tedious parts so you can focus on the interesting problems.