Name: React Summit US 2026
Start: 2026-11-17T15:00:00.000Z
End: 2026-11-20T22:59:00.000Z

Seungho Park

Daria Shabala

Violina Popova

Shifra Williams

Ayodele Aransiola

Vishnudhasan Govindarajan

Houda Mouttalib

Shubh

Filip Michalowski

Boris Karaivanov

Halil ALGÜL

Vitor Barbosa

Stavros

Tamara

Basseydou OUATTARA

quinton sheppard

Vladyslav Abramov

Fathima Fasna

Sean Leow

Pavel Petrov

Ellis Antaya

REYSMER WILLIANGEL VALLE RAMIREZ

Richie Leahey

Mik Khu

Tiffany Jensen

eran

Kasra Ghasemi

Joachim Justh

Chan Wen Tjun

Chris Yates

Yakovlev Eugen

Erin Murphy

AI is writing more code every day. The skill that won't get automated is knowing what to build and the system design thinking to make it happen at scale. In this full-day workshop, you will develop the judgment that sits upstream and downstream of implementation: how to validate a problem before you commit to a solution, how to understand the users you are actually building for (not the ones you imagine), how to prioritize ruthlessly when everything feels urgent, and how to establish feedback loops that keep you building the right things after you ship. These are not PM skills. They are the technical judgment that the best engineers have always had, and that becomes the defining skill as implementation gets faster and cheaper. What you will learn:- Validate before you build: surface real user pain, not solution-shaped stories- Understand users in context: close the gap between your mental model and theirs- Prioritize what deserves to exist: apply the Kano model and know what to cut- Translate decisions for stakeholders: navigate contested requirements productively- Close the loop: establish post-ship feedback habits that drive continuous improvement Who it's for: Software engineers with professional experience. No specific stack required. PMs and designers welcome.

Build the Right Thing: Product Engineering for Software Developers

Kent C. Dodds

<div>I'm not here to tell you software engineering is ending soon. Nobody can put a reliable date on that, and pretending otherwise is a distraction. But we also have to admit something humbling: a year ago, most of us would not have predicted coding agents would be this good. That should make us less confident about predicting what they'll be able to do one year, or five years, from now.</div><div> </div><div>So let's use "The Last Software Engineer" as a thought exercise. If AI keeps taking over more of the implementation work, what remains most human and valuable for us to do? In this talk, we'll take one step back from the hypothetical end and focus on the durable skill that has always separated great engineers from merely productive ones: judgment.</div><div> </div><div>The future belongs not to people who only know how to build, but to people who know what should be built. We'll talk about product engineering, accountability, trade-offs, constraints, evaluation, and how to keep making software worth having in an AI era.</div>

The Last Software Engineer

Vibe coding is easy, until you have to make an app that actually works. Sure, AI agents can spin up an impressive demo in minutes, but building a full-stack app that's robust, bug-free, and true to spec is where things get messy. And completely cloning an existing full-stack app? That's next-level difficult. Adding more agents just multiplies the mess, and spec-driven development piles stale specs on top of it. So... what does it actually take? In this talk, we'll explore a radically different approach, learned from building (and cloning) hundreds of apps for RL agent training environments and more: a living spec (yes, including state machines) and an AI-generated implementation that iterate on each other until reaching equilibrium, where the app provably does what the spec says. You'll learn how to model full-stack behavior as states, events, and effects, why letting agents modify their own workflows beats any rigid pipeline, and how to apply this experimental but extremely effective iterative loop to your own AI-assisted development today.

Cloning Full-Stack Apps with AI: What It Really Takes

David Khourshid

We all want software to run fast, and "performance" can include everything from network times to keyboard latency. But what about when you really do need Blazing Fast (TM) CPU speed from your code?  How do you know what sections of your code are slow, _why_ it's slow, and how to make it faster? Like writing code and debugging, performance optimization is a skill set that anyone can (and should!) learn. We'll look at key concepts and approaches for profiling and optimizing CPU-level code performance, using real-world examples based on my experience optimizing the widely-used Immer JS library.   You'll learn how to set up reliable benchmarks, capture profiles and interpret flame charts, identify hotspots in your code, and apply optimizations ranging from simple wins like local caching to larger architectural changes.  These techniques can help any developer's code run faster!

How I Made Immer Twice as Fast: Performance Optimization in Practice

Mark Erikson

Apple's first on-device foundation model gave developers a new execution path for AI features. iOS 27 expands what the system can do, while Android is moving in the same direction. If you last looked at this space around the initial release, the trade-offs and possible products have already changed. System-provided models have a distinctive place in the stack. They ship with the device, are optimized for its hardware, work offline, keep data local, and remove the need to package and maintain a model yourself. Their capabilities are defined by the platform and differ from cloud inference and models supplied by the application. This talk reviews the additions announced at WWDC and our work to bring the same approach to React Native on Android. Our integrations are built around the Vercel AI SDK, so applications can use familiar APIs regardless of where inference runs. We will look at what system models can now do, where their constraints appear, and which product features are particularly well suited to them. If your last experiment stopped at the initial Apple Intelligence release, this talk will give you a reason and a path to try again.

On-Device AI After WWDC: What Changed for React Native

Mike Grabowski

Your agent is great at writing terrible code, and terrible at writing great code. I guarantee it. But with just a few guardrails (many of which we've already using for many years in industry), you can steer it from slop to splendor. We'll cover essential tips and tricks that I've been using for years in open source and this year as a frontend developer at Sentry, namely: * Skills: teach your agent how to do the common tasks specific to your stack and repository. * Static analysis: linting! type-checking! These will save you bugs, time, and tokens. * Tests: know when to test, both in unit/integration/end-to-end and ad hoc at runtime with tools like MCP chrome-devtools. * Yourself: sometimes, it's better to just do the task yourself. Keep those skills fresh! We are at the "peak of inflated expectations" of a hype bubble, and it's easy to be overenthusiastic or overly pessimistic about LLM-based tools. But with the right hand-holding, they really can be magical for development.

Make AI Write Better Code: Skills, Tests, & Guardrails

Josh Goldberg

TanStack Start gives you three ways to run code on the server. Server functions, server routes, and server components. In this talk we'll take a look at what each does, why you would use one versus the other, and the drawbacks of each.

TanStack Start and the Server Factory: Three Ways to Run Code On the Server

Erik Hanchett

In this workshop we'll dive into the latest advancements in React and best practices for building modern React apps. We'll take a look at modern NextJS and React Router 7 Framework along with React's "React Server Components". We'll also talk about improving the data-fetching strategies of your SPAs along with options for migrating your SPA to modern React Router.

Modern React Architecture

Brad Westfall

Client-side AI is everywhere. With Transformers.js and WebGPU, we can run ML models directly in the browser.. But should we? In this talk, we'll explore when client-side AI makes sense and when it doesn't. We'll cover the technical foundations, examine real-world use cases, and compare the trade-offs: privacy vs. performance, small models vs. big capabilities, client vs. server. Which tasks belong in the browser, and which belong in the cloud? It depends!

It Depends: The Final and Honest Take On Client-Side AI

Nico Martin

What if the key to breaking into tech communities wasn't a perfectly curated LinkedIn profile or a flawless resume...but a well-timed joke? In this lightning talk, Roxy shares the unconventional "trolling" strategies that she used to get noticed and create real opportunities in tech. From showing up everywhere to leaning into memorable (and sometimes embarrassing) moments, these tactics built her network in ways she never expected, landing her invitations to emcee RenderATL, star in teh Web Dev Challenge, and land her first role in tech. This talk is for anyone who has ever felt like they were on the outside of a room they "technically" belonged in. :) Whether you are a senior engineer who has never spoken at a conference, or a newer developer trying to find your people, you'll walk away with an actionable list of actions to expand your network, get noticed, and create your own opportunities. She includes her own anecdotes as proof that being genuinely, authentically you (even the chaotic bits) is your biggest competitive advantage.

Trolling Your Way into Tech

Roxy Rodriguez-Becker

Have you ever wondered why you reach for TypeScript? I hate TypeScript and use it every single day. In 2026, React developers live in TypeScript-land by default. Most templates ship with .tsx files, lots of job listings require TS experience, and yet somewhere along the line we stopped asking ourselves “Why should we use this tool?"  TypeScript adds new and unique ways to trip yourself up. If you've ever had to cast something as unknown just to cast it again as the type you actually wanted, wasted an afternoon troubleshooting a never type that showed up uninvited to the party, or restarted your TS server as a reflex, this talk is for you.  Learn the professional TypeScript hater's diagnosis framework:  * which problems types actually solve * which problems can be fixed with better tools or processes * how to figure out if you’re reaching for TS on purpose or reaching for it as a magic pill By the end of this talk, you’ll know exactly where TypeScript earns its keep in your codebase and be more honest with yourself about why you reached for it in the first place.

TypeScript is a Coping Mechanism: A Professional TypeScript Hater’s Guide to Using TypeScript

Kayla Sween

**The question.** I wanted to find out how feasible local-first really is. Can an app run its AI on your own machine, against your own data, and still be worth using? Local may save on costs but is bounded by your hardware. **The experiment.** Music KB is a React app that turns YouTube music tutorials into a library I can search and ask questions of. Summaries, embeddings, chat and lesson generation all run locally. **What I found.** It got further than I expected. TanStack AI handles streaming, server-side tools, structured output and provider swapping, so Ollama drops in where a hosted API would go, and local carries most of the work. That's where MCP comes in. It lets you move past your local hardware constraints and take your data anywhere: expose a set of tools once, point Claude Code or Claude Desktop at them, and a frontier model works your library in place. Nothing leaves that you didn't choose to expose. The lesson isn't local or cloud, it's that you can use both. And TanStack AI makes it possible. You decide what runs locally, what's worth offloading to a frontier model, and whether hosting your own open-source model belongs in between. Pick by what the job needs and what a model can do.

Don't Build the AI Feature, Build the Interface: React, TanStack AI, and MCP

Paul Bratslavsky

<div>Join us for a hands-on workshop built for developers who want to move from idea to working software faster, using Claude Code, Anthropic's agentic coding tool. Unlike a typical autocomplete-style assistant, Claude Code lives in your terminal, IDE, or desktop app, reads and understands your entire codebase, and can take direct action: editing files, running commands, and handling git workflows, all through natural language.</div><div> </div><div>In this workshop, you'll initialize a Next.js project from scratch and use Claude Code to plan, build, and iterate on a real, working application. You'll set up a `CLAUDE.md` file to give Claude persistent project context and conventions, so you're not repeating yourself in every prompt, and use Plan Mode to review an agent's approach before it touches any code, keeping you in control of multi-step changes. Along the way, you'll write effective prompts, delegate multi-step coding tasks, and let Claude Code handle the repetitive work of scaffolding, wiring up components, and debugging, so you can focus on product decisions and architecture instead of boilerplate.</div><div> </div><div>By the end of the session, you'll have shipped a functioning Next.js application and gained a practical workflow for using Claude Code on your own projects, whether you're prototyping quickly or working within an existing codebase.</div><div> </div><div>No prior experience with Claude Code is required. Some familiarity with React or Next.js is helpful but not essential; we'll cover what you need to know as we go.</div>

Ship a Next.js App with Claude Code

Maurice de Beijer

React has changed a lot in the last year: React 19, 19.1 and now 19.2 brought a stable React Compiler, new hooks like useEffectEvent, the API, and better SSR primitives such as Partial Pre rendering. And more In this talk we’ll take a demo React app that’s full of effects, memoization and “old school” patterns, and modernize it step by step

Modernizing Your React App: Compiler, useEffectEvent, Activity & Friends

Vitor Alencar

React performance is not only about Lighthouse scores. This talk shows how to build React and Next.js applications that stay fast on slow networks, low-end devices, and real production conditions. Amani Kanu will share practical patterns for reducing JavaScript cost, avoiding unnecessary renders, improving data loading, using smarter caching, and designing user experiences that remain usable when network speed and device quality cannot be guaranteed.

Building Fast Apps for Slow Networks and Low-End Devices

Amani Kanu

React gives developers a false sense of security—especially in the era of AI-assisted code and Server Components. Faster abstractions don’t remove risk; they shift it. This talk exposes common front-end security mistakes in modern React apps (including trends shaping <a href="https://focusreactive.com/blog/top-reactjs-development-services-in-2026/" target="_blank">React development</a> in 2026) and shows how attackers exploit blurred client–server boundaries. You’ll leave with a clear mental model of modern React threat surfaces and practical techniques to build defensive applications that hold up in 2026.

React Won’t Save You: Front-End Security Mistakes We Keep Shipping

Kristiyan Velkov

This talk digs into what it really takes to run LLMs efficiently on mobile hardware in a React Native environment. We’ll examine the constraints teams face - memory limits, model loading strategies, inference performance, platform-specific APIs - and how they shape real-world product decisions. From there, we’ll introduce a React Native library that provides two complementary ways to integrate on-device AI: cross-platform, state-of-the-art models that run locally on both Android and iOS, and a dedicated path for leveraging Apple Intelligence capabilities on supported iOS devices. We’ll walk through the architecture, usage patterns, and trade-offs of each approach, and discuss best practices for delivering smooth, low-latency AI experiences without relying on the cloud. We will cover both native libraries for mobile AI &amp; LLM model inference, and the available wrappers for React Native, along with the trade-offs, capabilities, hardware compatibility, model format compatibility and compile-time model optimizations (operator fusing, vectorization, memory planning, operations accelerated for specific hardware) considerations so that the audience is aware to pick the best solution for their specific use cases.

Efficient On-Device Llms in React Native Done Right

Artur Morys-Magiera

<div>If I was perfectly comfortable with building single-page apps, what does migrating to server components actually do for me? Would it cost more?  What could it actually do that wasn't possible before? And why was React going in this more complicated direction? So I tried it, porting my SPA Firebase app to RSC to see what happened. This talk is the result, warts and all, what was better, what wasn't, what it meant for performance and cost, and how much of Firebase's traditionally client-focused services can be used in the server.</div><table><colgroup><col></col></colgroup><tbody><tr></tr></tbody></table>

When (Not) to Use Server Components in Interactive Web Apps

Jeff Huleatt

Cynthia Wang

Learn how to easily add core infrastructure to a React app with ReactFire and FirebaseUI, add AI features with Firebase AI Logic, and deploy and monitor a production server-rendered React app with Firebase App Hosting and Cloud Monitoring.

Production React Apps With Firebase and Google Cloud

TypeScript’s type system is uniquely powerful, but most developers only scratch the surface of what it can do. In this code-driven session, you’ll explore some of the weirdest and coolest features of TypeScript: from the infer keyword and recursive types to using types for arithmetic and even recreating Wordle entirely with Typescript types. You’ll discover fascinating tricks that might seem extreme and nerdy, and wonder when you’d ever need them. Spoiler: maybe rarely; but sometimes, these quirks can come in especially handy. More importantly, it’s just plain fun to explore the limits of TypeScript’s type system.

The Fun Side of Advanced TypeScript: A Live Coding Session

Dante De Ruwe

Most AI agents touching a React app today do it the crude way, scrape the DOM, guess at selectors, simulate clicks and hope. WebMCP proposes something different: defining explicit tools, backed by JSON schemas, that give an agent a real contract instead of a markup tree to reverse-engineer. I built a small two-agent setup to actually test that contract against real React state, not just read the explainer. Some of it worked cleanly, plain state, simple mutations expose well as tools. Some of it didn't: derived state, Suspense boundaries, and effect-driven updates don't map onto a clean tool definition the way the spec makes it look like they should, and each one needed a different workaround. I'll walk through the real component code, the exact points a tool-based approach broke down, and what I changed to make it work — a grounded account of where WebMCP's tool model holds up under real React state, and where the spec still has real gaps, from someone who's actually built against it rather than just read the explainer.

Two Agents, One React App: What Breaks When You Actually Wire State to an MCP Server

Sulagna Ghosh

In recent years we've seen browsers deliver powerful APIs. What does this mean for the future of React development? A future with less JavaScript for interaction logic. In this talk we'll discuss new browser APIs released in 2026 and how you can leverage these new APIs and the impacts they will have on, application performance, developer experience, user experience, and the future of React app development.

A JavaScript Less Future - New Browser APIs and Their Impact on the Future of React Development

Ameer Sami

What happens to your design system, your code quality standards, and your developers' wellbeing when AI is writing significant portions of your frontend — and doing it faster than any review process can keep up? Jaayden Halko is a Senior Frontend Engineer at Coder, where he has worked on AI developer tools: Mux, a parallel AI coding agent multiplexer, and Blink, a platform for building and deploying custom AI agents. In this talk, he shares the unexpected frontend challenges that emerged when AI was used heavily to develop the UI. You'll hear what actually happened when code reviews became optional, whether AGENTS.md context files meaningfully improve AI-generated UI quality, how different AI models have distinct aesthetic preferences that drift your design system and how UI design choices directly contribute to or mitigate developer burnout in AI-heavy workflows. This is a practitioner's talk discussing the decisions, trade-offs, and a forward look at what AI-native developer tool interfaces need to become.

When the AI Writes the UI: Frontend Lessons from Shipping Two AI Developer Tools

Jaayden Halko

A React tree wrapped in an Electron cross-OS runtime, orchestrating a PDF engine without blocking the main thread. This talk walks the real code: how workers perform optical character recognition against an OffscreenCanvas while the event loop keeps rendering, uninterrupted. Heavy garbage collection events and memory allocation are kept off the main thread.

The React Tree Beyond the Web: Driving a Cross-Platform PDF Engine

Alexandros Gounis

What if your React application could run its own AI model, remember context, and perform AI tasks without sending data to a backend? Modern browsers are gaining the capabilities needed to make this possible. Local model inference, Web Workers, browser storage, and streaming APIs allow us to move parts of the AI runtime directly into the browser. In this talk, we'll build a small React application powered by a local Gemma / Kimi model and progressively turn it into a browser-native AI runtime. We'll focus on three building blocks: running inference locally, giving the application persistent memory, and moving AI work into background workers. Along the way, we'll see how this changes the way we think about React architecture and what belongs in the frontend. The result is an AI application that can work locally, keep its context, and continue processing without depending on a cloud-hosted AI API.

Building an AI Runtime in the Browser with React and Open Models

What does it take to build a React UI that talks to an AI agent, streams responses in three languages, and runs on both WhatsApp and the web — in production? In this case study, I'll share hard-won lessons from shipping a multilingual disaster risk awareness platform for Sri Lanka, covering real-time streaming UIs, auth-aware chat components, and the React patterns that make AI agents feel alive rather than laggy and broken.

React Meets RAG: Building Production Multilingual AI Agent Interfaces

Sachin Mamoru

Asking an AI to refactor 200 files across your React codebase burns tokens, takes minutes, and sometimes hallucinates. A codemod can do the job reliably (and for free). But if you're not familiar with writing codemods, that's a big step to climb. In this talk, you'll learn how <a href="https://focusreactive.com/blog/how-we-use-ai-to-migrate-any-cms-a-prismic-to-payload-walkthrough/" target="_blank">to use AI</a> to craft the codemods your team needs. Starting with a look inside the React 19 migration recipe, we'll build a custom codemod live for a pattern no recipe covers.

Where We're Going, We Don't Need Tokens: AI-assisted Codemods For React

Nicolas Carlo

Publishing a shared component library feels like a milestone, until a single change breaks multiple applications at once. While working on a monorepo at EPAM Systems powering 8 production applications for a global supply chain platform, we built a shared ecosystem of independently deployable frontend packages: authentication, navigation, app shell, user profile, and UI components. On paper, it promised consistency and speed. In reality, it introduced a new class of problems, subtle, cross-app, and often hard to debug. A mismatch in React versions led to duplicate instances and unpredictable behavior across apps. Small feature requests from different teams slowly turned shared components into overly flexible, inconsistent abstractions. Even “safe” refactors required coordinating across teams, managing rollouts, and avoiding breaking changes in production systems we didn’t fully control. This talk goes beyond best practices to explore the real trade-offs of shared frontend architecture at scale. I’ll walk through concrete failures, decisions, and constraints we faced — and the strategies that actually worked: strict dependency contracts, opinionated API design, staged migrations, and clear ownership models. If you’re building or maintaining shared packages in a monorepo or multi-app ecosystem, this talk will help you avoid common pitfalls and make better architectural decisions — before they impact multiple teams at once.

The Hidden Cost of Shared Frontend Code: Lessons from 8 Apps and One Monorepo

Mansi Manhas

A requirement arrived with a simple solution: add stricter address validation so customers cannot proceed with invalid addresses. But this address form lived inside critical payment and ordering flows, where adding friction could harm payment completion, purchases, and customer experience. In this talk, I’ll walk through a production case study of how we reframed the problem from “prevent invalid addresses” to “collect more valid addresses,” explored address autocomplete as a lower-friction solution, defined success and guardrail metrics, and chose a release strategy that helped us learn without putting the funnel at unnecessary risk. Attendees will leave with three practical questions they can apply to their own frontend work: what are we really building, what impact are we looking for, and how should we release it?

When “Just Validate the Form” Becomes a Product Engineering Problem

Fadila Fidina

We’ve all seen flashy web demos of AI agents streaming dynamic React components. But when you ship these features to production, your biggest bottleneck isn’t prompt engineering-it’s the cloud invoice. A single rogue frontend re-render loop or an unoptimized context window can quietly drain thousands of dollars in API costs overnight. My talk introduces a pragmatic, full-stack `` architecture built directly into modern React applications. I will show you how to build a two-tier defense system: using Next.js Server Components for semantic caching and dynamic LLM routing on the server, paired with custom client-side hooks that act as financial circuit breakers. You will walk away with a production-ready blueprint to build powerful agentic features that are both technically robust and financially viable.

const [cost, setCircuitBreaker] = useFinOps(): A Guide to FinOps for Frontend Architects

Hrushikesh Pokala

Supply chain attacks are no longer a theoretical threat - they are a daily reality. GitHub repositories, npm packages, VS Code extensions, biggest open-source libraries: all have been weaponized to compromise thousands of developers and their users at once. New incidents surface every day, each one larger than the last, and no project is out of reach. Every breach gets its post-mortem. But by the time you read it, the next attack is already being planned. This talk is about getting ahead of it. We'll look at why anyone can fall victim, and, most importantly, what you can do about it. Small changes to how you work can cut your exposure dramatically. Not by becoming a security expert, but by learning to ask one uncomfortable question about everything you depend on: why do I trust this?

Trust Nothing, Ship Safely: Surviving the Supply Chain Attack Era

Nina Torgunakova

Software development is fundamentally an exercise in composition. We take big, complex problems and organize them into smaller, solvable parts. So the question isn’t whether you’re composing or not. It’s whether you're composing with intention. We aren’t here to rehash “composition vs inheritance” or preach about the dogmatic use of the latest architectural trend. Instead, we’re going to explore the thought process that goes into structuring and designing code so that you spend less time writing, less time reading, and less time debugging. In this presentation, we will cover a practical three-step process for designing readable and low-friction systems: * Split responsibilities to reduce complexity. * Strengthen interfaces for wide applicability. * Connect components to improve maintainability. This talk equips you with the skills to manage your cognitive budget even when you're facing developer fatigue, mounting technical debt, or AI-generated bloat. Let’s stop being afraid of our own codebases.

Better Living Through Composition

Sarah Padovani

When you think of it, browsers can be the perfect containers for running all sorts of workloads - Everybody has them, each tab is an isolated environment and they have a very rich API. So why not use the browsers in your organizations to act as containers to run your workloads and save money on servers? In this session I’ll explain the concept and demonstrate it running javascript (of course!) tasks for AI, concurrent batching, PDFs creation and more. This is the new cloud native!

Browsers Are the New Containers!

Dan Erez

Barrel files — those innocent index.ts re-export hubs — are one of the most popular patterns in the React ecosystem, and one of the most expensive. In dev mode there is no tree-shaking: a single `import { Button } from '@/components'` drags every re-exported module into the compile graph. I measured just how much that costs. In a synthetic Next.js lab, shrinking a 2000-module barrel down to 200 re-exports cut dev-server memory growth by roughly 88%. In a real production codebase, de-barreling the shared module graph took a blank page from 6,780 compiled modules and ~4.9 GB of dev memory down to 2,215 modules and ~2.3 GB — while config-only "fixes" like optimizePackageImports quietly failed to move the needle. In this talk I'll walk through the experiments and the numbers, show which import styles actually determine what enters the module graph, and close with concrete guidance for library authors: how to design entry points and exports maps so your users never have to pay the barrel tax.

The Hidden Cost of Barrel Files

Lianwen Wu

Ads Manager powers 84% of Meta's Ads Revenue, but its decade-old codebase was stuck on React class components — blocking modern patterns like hooks, Relay, and React Compiler. Manual migration of 10k+ components class to functional component was impractical. In this talk, I'll show how we built an AI codemod pipeline using LLMs that achieved a 5x speedup, migrating 3k+ components with a 99.6% success rate. I'll cover the tradeoffs between AST and AI codemods, how to classify components by complexity for targeted prompts, and the grading/eval strategies that made non-deterministic AI agents production-ready.

Class To Function Migration with AI Codemods: Migrating 10k+ Components at Scale

Shubham Chaurasia

Stop prompting. Start orchestrating. In four intense hours you'll go from using Claude Code like a faster autocomplete to commanding it like a senior engineer commands a team: engineering its context, deploying fleets of subagents, locking it down with hooks, and turning it loose on work that runs without you.Every Claude Code user hits a ceiling where the easy wins run out. The agent handles small stuff beautifully, then loses the thread on anything real. The difference between that ceiling and real mastery isn't better prompts. It's control. This workshop is about control.You'll spend the whole four hours inside CLASH, a real full-stack application, handed to you fully built so nothing stands between you and the hard parts. A serious codebase is the point: it's the only place agentic engineering shows you whether it actually holds up.The throughline is context. Treated carelessly, the context window fills with noise until the agent drifts. Treated as a resource you engineer, it becomes the biggest lever you have. From there the toolkit opens up. Repeatable work becomes a reusable Skill. Noisy, exploratory work goes to subagents that run in their own isolated context, several at once when the job allows. Hard rules become hooks the agent cannot cross. Your own systems come into reach through MCP.Then you let go of the wheel, carefully. The same agent that pairs with you can run headless in a pipeline, drive a long task to a defined finish on its own, or live inside your software through the Agent SDK. We close by setting two greenfield methodologies, Spec Kit and BMAD, side by side, so you leave knowing not just how to drive the agent but which approach fits which problem.Two ideas hold it together: context is king, and you push it, you own it. This was never about generating code faster. It's about staying in command while the agent does more.This is an advanced session for engineers, tech leads, and architects who already use Claude Code every day and want to reach the top of the curve. We move fast, and we start in the deep end.

Claude Code: Black Belt

Pawel Sawicki

React Summit US

Network with fellow front-end and full-stack engineers, learn from industry experts, and promote your ideas all while experiencing the exciting vistas of Manhattan!React Summit offers a hybrid format with both remote and in-person participation.The first day will be streamed from the New York venue including hybrid networking features and interactive entertainment; and the second day, as well as the numerous free workshops, will be streamed to the global audience online.Take advantage of being a part of the React Summit US conference!

React Summit US 2026

FocusReactive

Hygraph

Storyblok

Sentry

Expo

Firebase

Render

Meticulous

Strapi

Move faster with intuitive React UI tools

Make your app the best it can be with Firebase and generative AI

Storyblok is a CMS that works with all modern frameworks and platforms so you are completely free to choose the best option for your project. Kickstart a new CMS project with your favorite technology in a matter of minutes, and for free.

Your AI is only as good as your content. Make it joyful.

Sentry is essential for monitoring application code quality. From Error tracking to Performance monitoring, developers can see clearer, solve quicker, and learn continuously about their applications — from frontend to backend.&nbsp;

Expo and EAS are an ecosystem of tools that help you develop, review & deploy

Render is an intuitive cloud platform for developers who want to ship production-grade apps and agents without managing infrastructure.

The intuitive cloud platform for deploying any app or agent.

Exhaustive verification. With zero developer effort.

Strapi is the open-source headless CMS for React. It’s 100% TypeScript, fully customizable, and developer-first.

FocusReactive is an&nbsp;<meta charset="utf-8" id="isPasted">engineering-led <a href="https://focusreactive.com/" target="_blank" rel="noopener noreferrer">Headless CMS Development Company</a>&nbsp;and&nbsp;<a href="https://focusreactive.com/next-js-expert-agency/">NextJS&nbsp;development experts</a>. Independent partners of Payload CMS, Sanity, Storyblok, Vercel and Shopify. Delivering&nbsp;<meta charset="utf-8" id="isPasted">Composable content platforms built for AI SEO, growing teams, and marketing velocity.

React Summit US 2026

The biggest React conference in the US