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

Olivier Tassinari

Violina Popova

Seungho Park

Vishnudhasan Govindarajan

Daria Shabala

Shifra Williams

Ayodele Aransiola

David Pugh

Amanda Witecki

Houda Mouttalib

Shubh Gawhade

Nonso Otoh

Prithive Raj MuraliKrishnan

Filip Michalowski

Paul Bratslavsky

Ryan Ogden

Boris Karaivanov

khouchane Mahmoud

Halil ALGÜL

Vitor Barbosa

Nicole Wojakovski

Mathieu Habegger

Stavros

Tamara

quinton sheppard

Basseydou OUATTARA

Fathima Fasna

Vladyslav Abramov

eran

Pavel Petrov

Yakovlev Eugen

Ellis Antaya

REYSMER WILLIANGEL VALLE RAMIREZ

Richie Leahey

AI is writing more code every day. The skill that will not get automated is knowing what to build. And how to ship it with confidence when agents do most of the implementation. In this full-day workshop, you will practice product engineering judgment upstream of the code, then put an AI-native delivery loop underneath it. You will learn how to validate a problem before you commit to a solution, understand the users you are actually building for, prioritize ruthlessly, and make reversible product decisions. Then you will set up the systems that let agents implement safely: shared intent and context, durable primitives, verification gates, feature flags, and outcome review instead of reading every diff. What you will learn: 1. Validate before you build: surface real user pain, not solution-shaped stories 2. Align intent with agents: shared understanding, options with trade-offs, and clear "done" 3. Prioritize what deserves to exist (cut ruthlessly) 4. Design two-way doors: use flags and reversible decisions so you can ship and learn 5. Build agent-ready primitives: structure the repo so agents reuse building blocks instead of inventing slop 6. Close the delivery loop: tests, AI review, CI, preview environments, and risk-aware shipping without babysitting every line 7. Keep the system improving: friction logs, cleanup, and feedback loops after you ship Who it's for: Software engineers with professional experience who already use (or are starting to use) coding agents. No specific stack required. PMs and tech leads welcome. Format: One full day, hands-on. Bring a laptop, take notes, and have your preferred agent ready to go!

AI-Native Product Engineering

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

AI is changing how we build software. We can generate more code, faster, but we still have to live with the architecture, dependencies, and maintenance decisions that come with it. Open source still matters, and so does knowing when to use something that already works. In this talk, we’ll explore why a few words like “use TanStack” can save you time, effort, tokens, and heartache. Good defaults and proven libraries give you and your AI tools a shared foundation, so you can spend less time rebuilding common infrastructure and more time on what makes your application useful. We’ll look at which decisions are still worth making deliberately, how open source helps agents make better choices, and why generating code faster makes choosing the right foundations more important than ever.

Use TanStack

Tanner Linsley

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

in this talk I’ll be exploring how agents have opened the doors to being able to create nearly anything you dream up. we’ll examine the intersection of ui/react/interfaces with hardware, both electronic and mechanical, and what that means for engineers moving forward.

You Can Build Anything Now

Ken Wheeler

Most agents fail in production for reasons the model can't fix. In this workshop, we start from an agent that fails and lies about it, then harness it step by step until it does the job reliably, without a single change to the prompt. Workshop outline: 1. The failing agent: why it breaks, and why it claims success anyway 2. The agent loop, built up from an empty loop 3. A tool registry and context management 4. Guardrails, context compression and retries that hold whichever model sits underneath 5. Deterministic verification, so the agent fails honestly instead of claiming success 6. Moving secrets and fragile steps, like login, out of the model and into the harness 7. A harness plan for the agents you're building

Build a Production Agent Harness

Tejas Kumar

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

Are Frameworks Dead in the Age of AI?

Jack Herrington

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

Reviewing PRs is something every engineer should be doing, regardless of how senior or junior you are or how new you are to a team or codebase. It's what keeps our codebases manageable and our code quality high... if we do it right. Ultimately, we're responsible for every line of code that gets merged into our codebase. In this talk, we'll cover specific strategies to become the best code author and reviewer you can be and use PR reviews as a mentorship exercise in your teams.

Becoming a Code Review Champ

Isabela McLenachen

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

<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 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

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

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

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

Jeff Huleatt

Cynthia Wang

<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

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, 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 Coder Agents, a self-hosted platform for delegating development work to coding agents. In this talk, he shares the unexpected frontend challenges that emerged when AI built much of the UI, including agents building their own interface. You'll hear what happened when code reviews became optional, whether AGENTS.md files and agent skills meaningfully improve AI-generated UI quality, how different models have distinct aesthetic preferences that drift your design system and how UI design choices contribute to or mitigate developer burnout in AI-heavy workflows. This is a practitioner's talk on the decisions, trade-offs, and what AI-native agent 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

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

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

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

A generation grew up with screens everywhere, and everyone assumed they'd show up as technology experts. Instead the tools got so easy that they never had to troubleshoot anything, and "digital native" stopped meaning anything. I think "AI native" is heading the same direction, and that's good news. If you're working right now, you're learning AI at the best possible time to learn it: it's good enough to change how you work and unreliable enough to teach you where it breaks, and you still have the fundamentals to tell the difference. This talk is about getting to the next level from wherever you're starting, when many of the technical skills that leveled up engineers in the past won't be enough anymore. I came into engineering from a different career, made it to staff at GitHub, and am now on a small team getting to explore AI products at Bluesky. Many of the skills that have advanced my career aren't the technical ones at all, which is why I think that AI tools actually make career advancement easier. I'll cover the stuff that never makes it into a job description: making sure your manager knows what you're doing, building the community around you that makes the next step possible, and the product management skills that are critical for any software engineer to know now.

Getting to Senior and Tech Lead When the Tools Do the Technical Part

Brittany Ellich

Moving from junior to mid-level to senior is mostly about improving your technical skills, but moving into technical leadership is different. It's less about producing more and better code, and it's more about deploying your technical experience for the purposes of enabling others. This certainly requires a body of technical experience, but it also requires a patience for politics, professionalism, and humility.

More than a Senior++ Engineer: What Makes a Good Tech Lead

Ben Makuh

If you've left the same code review comment twice, it should probably become a new lint rule. And if you've written that lint rule, this is your sign that there's a component or hook you're still missing. Our team built custom ESLint rules for our React app to catch things like stale dependency arrays or hand-rolled versions of components we already have. We'll draw on those to look at how to climb that ladder, and just as importantly, when to stop.

Lint for the Dryer: Don’t Repeat Yourself in Reviews, Agents, or Docs

Tucker Chapin

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

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

Self-hosting Next.js has always been easy... if you're willing to part with everything that makes it Next.js. ISR, image optimization, middleware at the edge, streaming, cache components—the features that sell the framework are the first casualties. That's changing. James walks through what the Next.js Ecosystem Working Group has been building and shows how you can run a full-featured Next.js app on your own cluster—with conformance results from the Next.js team to back it up.

Self-Hosting Next.js With All Its Bells and Whistles

James Daniels

Exhaustive testing is the missing piece to autonomous software development. This talk describes the challenges with exhaustive testing and various technical approaches to solving them. For example: For a given code change, what tests do you run? This talk discusses both static analysis and agentic approaches to selective test execution. How do you avoid race conditions when executing tests in parallel? How do you achieve full visibility? Determining whether a code change is good to ship requires more than just the absence of failures on pre-defined assertions. It requires the ability to quickly understand the full impact of the change.

How Do You Trust the Code Your Agent Is Writing?

Geno Racklin Asher

What if building a native app took a minute instead of a build pipeline and a laptop? In this talk, we'll walk through Backtick, an open-source project where AI writes your React Native app in the cloud and you run it natively on your phone, with no laptop or build step in between. We'll explore the architecture behind server-driven native screens, how a single file can span both server and client, and what it means when "install once, every app is a link" replaces Code → Build → Store Review → Install. We'll also be honest about what's still unsolved in 2026: versioning, isolation and permissions, and app store rules. You'll leave with a clear picture of how AI-assisted, server-driven React Native works today, and what it will take to build a browser for native apps, where anyone can make an app and share it as a link.

Vibe Code React Native Apps From Your Phone: No Computer Needed

Jean-François Bisson

Many React developers use server rendering to improve performance. Before React 18, however, all four (4) steps in the server rendering process (data fetching, rendering to HTML, loading JavaScript, and hydrating) had to be completed for the entire app at once. This meant that a bigger or more complex part of your app would block other parts from moving onto the next step, making your app appear slower. Thanks to optimizations in React 18, you can use Suspense to break your app into smaller parts that go through these steps independently. Users benefit from an app that they can see sooner and interact with almost instantaneously!

Streaming Server Rendering with React Suspense

Shaundai Person

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.

Meticulous gives you exhaustive E2E verification, with zero developer effort. Rolled out across ElevenLabs, Notion, LaunchDarkly &amp; Dropbox, who can all agree that frontend code testing is dead.<a href="https://www.meticulous.ai/" target="_blank" rel="noopener noreferrer">Learn more</a>.

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 <meta charset="utf-8" id="isPasted">engineering-led <a href="https://focusreactive.com/headless-cms-development-agency-united-states" target="_blank" rel="noopener noreferrer">Headless CMS Development Company</a> and <a href="https://focusreactive.com/next-js-expert-agency/">NextJS development experts</a>. Independent partners of Payload CMS, Sanity, Storyblok, Vercel and Shopify. Delivering <meta charset="utf-8" id="isPasted">Composable content platforms built for AI SEO, growing teams, and marketing velocity.

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 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.