Name: React Summit 2026
Start: 2026-06-11T22:00:00.000Z
End: 2026-06-15T22:00:00.000Z

Taz Singh

Olivier Tassinari

Ciarán Curley

Lera

  Neha  Seth

Rafael Piazdecki

Irina Baeva

Aleksei Podgaev

 Tapas Adhikary

Seungho Park

Matheus Albuquerque

Jo Franchetti

Rahul Nanwani

Richard Carrigan

Rajni Gediya

Thibault Van den Broecke

David Pugh

Sander Vervaeke

Shubh

Remko van Laarhoven

Benjamin Rensch Vinterberg

Jason Chaw

Jose Pablo Fernandez Guerra

David Barry

Jeroen van Wissen

Bogdan Plieshka

Mangirdas Darguzis

Azadeh Farshidi

Ricardo Machado

Barbara Ferreira

Karyna Bunta

Sam Bauters

Petar Kuzmanov

Gerson Enriquez

Web development has always moved in cycles of hype, from frameworks to tooling. With the rise of large language models, we're entering a new era of 'vibe coding,' where developers shape software through collaboration with AI rather than syntax. This talk explores what that means for the future of coding, especially in frontend development, and how it echoes the past while redefining what comes next.

From Vibe Coding to Vibe Engineering

Kitze

The web platform is not the same as it was in 2013, but many of us are still living in a world where every UI element is constructed from scratch in React. In this talk, Scott explores advancements in the web platform that can greatly simplify your React components while making them more accessible.

This Component Could Have Been A Class

Scott Tolinski 

In this workshop, we'll go beyond the fundamentals and explore some of the more powerful features React Query has to offer. You'll gain a deeper understanding of how it works under the hood and learn how to write scalable, maintainable React Query code.Together, we'll build a simple example app and incrementally enhance it with one core objective in mind: delivering the best possible user experience. That means snappy interactions, minimal layout shifts, and avoiding unnecessary loading spinners wherever we can.To achieve this, we'll dive into advanced techniques like various forms of prefetching (including integration with route loaders), seeding the query cache, crafting smooth paginated experiences, and even persisting query state through full page reloads using persistence plugins.Note: You should have prior knowledge about React Query if you attend this workshop.

React Query - Beyond the Basics

Dominik Dorfmeister

Over the past year, the way I build applications has changed dramatically. Projects that once took weeks now take days with the help of AI. But the biggest shift isn’t speed, it’s how I learn and how I teach. In this talk, I’ll share how I’ve started using AI not just as a coding assistant, but as a teaching layer inside my development workflow and content. I’ll walk through how I use AI to explore architectures, validate decisions, and iterate faster, and how I bring that same process into tutorials watched by millions of developers. This approach shifts learning from passive consumption to active collaboration. Instead of just showing what to build, I focus on teaching how to think with AI. I’ll also address the growing gap between fast “vibe coding” and real understanding, and how using AI intentionally can help developers build both speed and depth. This talk offers a practical perspective on how AI is reshaping not just how we build software, but how developers learn, grow, and think in the process.

​How I use AI as a Technical Educator

Adrian Hajdin

A technical breakdown of how the Claude Code Desktop runtime discovers, loads, and executes Skills. We'll cover the SKILL.md spec beyond the basics, frontmatter parsing, description-based triggering, file system scoping, and how skills compose with MCP and hooks in a single session.<div> </div><div>Then the practical side: what makes a skill trigger reliably, how to scope it without bloating context, and the common failure modes when moving from CLI to Desktop.</div>

Skills in Claude Code Desktop: Architecture and Execution Runtime

Daniel Ávila

React is a library for "rendering" UI from components, but many users find themselves confused about how React rendering actually works.  The new React Compiler promises to "automatically optimize your React app"... but what is it actually _doing_ to your component?  How does that complex compiler-written code actually make your app faster?  How does the Compiler change the long-standing fundamental model of React's rendering behavior? In this talk, we'll clear up the confusion and provide a solid foundation for understanding when, why, and how React renders.  We'll look at React's built-in techniques for optimizing rendering performance, including the little-known trick that the Compiler depends on.  We'll demystify the Compiler's output and break down exactly what that code does.  Finally, we'll see how the Compiler rewrites our mindset of using React itself, and what that means for learning and using React in the future. You'll leave with an accurate mental model of React's behavior before and after the Compiler, and be ready to use React more effectively.

A Guide to React Compiler Rendering

Mark Erikson

We all review code differently. Some developers carefully read side-by-side diffs in the browser. Others refuse to leave the terminal and review purely via CLI. And let's be honest—sometimes we just click "LGTM" without looking at the code at all. In this talk, I will demo these different code review styles, explore why they all still lead to a "review bottleneck," and show how AI can speed up the process no matter which workflow you prefer.

CLI, GUI, or Just Blind Trust? A Tour of Code Review Styles

Santosh Yadav

Observability isn’t just for backends anymore. As React applications grow more complex distributed across CDNs, APIs, and micro-frontends understanding what’s happening in production becomes a full-stack challenge. In this talk, we’ll explore  what observability means for modern frontend architecture , how to design, instrument, and standardize telemetry for your React apps.

Architecting Observability in Modern React Apps

Neha Sharma

Most apps treat the server as truth. Peer-to-peer flips that: state starts local, users carry the data, and shared truth emerges without routing every interaction through a central backend. Outline: - The normal React/backend model - Server/database as the source of truth - The local-first flip - Local state becomes the primary user experience - From local-first to peer-to-peer - Users replicate state directly instead of only syncing through APIs - Using a chat app as the running example, with quick comparisons to docs, boards, and media sharing - How shared truth emerges - User actions as signed operations in append-only logs - Deterministic app rules decide which operations are valid - Peers agree on ordering and can independently verify the resulting state - What this means for React developers - UI becomes a view over local replicated state - Reality check and takeaways - P2P does not remove backend complexity; it turns it into protocol and state design - Tradeoffs include availability, permissions, conflict handling, and migrations - These are normal apps with a different source of truth — and they're possible now Will keep it high-level, practical, and example-driven. Including some lessons from building real peer-to-peer apps like Keet.

P2P React: Local-First State, Shared Truth

Mikkel Malmberg

The Evolution of App Development

Kadi Kraman

This is a 20-minute talk for people already using AI agents day-to-day. It compares two ways of building the same feature: one with iterative prompting, one with a spec written first, and walks through the actual outputs of both. From there, I cover the structure of a useful spec and how teams can share and co-write specs before handing off to an agent. I'll also cover what makes the spec-first approach worth the initial overhead: less drift, reviewable decisions before any code is generated (more cost effective), and context awareness over time. But, it’ll also be honest about where the approach breaks down. The audience should leave with concrete practices they can apply to their next piece of work, whatever SDD framework they choose.

We Need More Than Prompts

Alex Garrett-Smith

Throughout history, empires rise and fall. Throughtout web development, frameworks rise and fall. In 2026, we are firmly in "late stage React", where young devs can't remember the world any other way, and older devs are keeping their eye on the horizon for what's next.What if I told you there was a TypeScript-first UI framework created by a member of both the React _and_ Svelte core teams focused on fine-grained reactivity and rendering speed that will look instantly familiar to you?I'd like to introduce you to Ripple, show you around its syntax and philosophy and stimulate your mind out of the Present and into the Future.

Ripple: the Good Parts of React, Svelte, and Solid

Erik Rasmussen

React Bits: The Art of Standout UI

David Haz

Building app-like UX on the web has historically meant reaching for an SPA. You ship the data layer to the browser, manage a client cache, juggle loading states, coordinate mutations, and write a lot of code to keep the UI feeling fast and fresh. The result can be great, but the cost is high, and the model gets harder to maintain as your app grows. Next.js takes a different path. Since React Server Components first landed, we’ve been working toward a way to build where each piece of your app runs where it belongs, while the mental model stays the same: components. In this talk, you’ll see how that translates into instant-feeling UX, streamed UI, fresh data, coordinated updates, caching across the stack, and strong Core Web Vitals that hold up as your product scales.

What RSCs Can Do in Next.js Today

Aurora Scharff

LLMs are powerful but unpredictable and most tutorials skip the part where you actually have to deal with that in production code. This workshop teaches you to use generative AI as an engineering tool: how to structure prompts around schemas, validate and repair non-deterministic output, and run models locally so you control the cost and the carbon. We'll generate a world for a roleplaying game as our teaching context it's a fun, low-stakes domain that makes the hard problems visible. The patterns you leave with apply anywhere you want to bring LLMs into a typed system. No ML background required. Just TypeScript and a laptop.

Personalisation Without the Price Tag - Local LLMs for JavaScript Developers

While tools like Jest, Jasmine, Karma, and Testing Library  were always there when we needed them for testing our web apps, it's time to move on. In this talk, we'll revisit the battle scars they left behind, and explore how Vitest isn't just trendier — it's the result of hard-earned lessons in speed, reliability, and developer experience. You'll leave with: - A sense of closure for the old stack. - A tour of the modern features Vitest brings to the table. - Clarity on "Partial" vs. "Full" Browser Mode. - The anatomy of a maintainable test: Fakes, Object Mothers, and patterns that future-proof your specs. - A look at Testronaut — a testing companion that takes these patterns further. Come for the nostalgia. Stay for the clarity. Leave ready to cook.

Ashes to Ashes, Spec to Spec: The Rebirth of Modern Testing

Younes Jaaidi

React Server Components are powerful, but most implementations make them feel like a fixed, server-owned tree. TanStack Start takes a different approach: it treats RSC as data - server-rendered fragments the client can fetch, cache, and compose into its own UI tree. Because RSC fit into the same caching story as data, they can use TanStack Router’s built-in cache, TanStack Query, or other caches directly - without introducing a separate caching model just for components, while enabling fine-grained caching and invalidation. Built on TanStack Start’s existing primitives, the model also composes cleanly with middleware and with different rendering strategies, from streaming SSR to no SSR at all.

Tanstack Start and How It Supports React Server Components

Manuel Schiller

Over the past year, model intelligence has skyrocketed, and agent tooling has improved significantly. However, there's still a gap: most AI agents don't have the procedural, domain-specific expertise needed to do real work inside real products, especially in React apps, where a small behaviour change turns into user-facing regressions.  In this talk, I'll show how leveraging Agent Skills changes how you build AI features in React: from prompt tweaking to shipping packaged guides, resources and scripts that turn a general-purpose agent into a product-specific one via the Agent Skills protocol. I'll also show a practical way to do this in React apps without changing your current frameworks or LLM, with evals and versioning in place to prevent regressions.

Don’t Build Agents, Build Agent Skills Instead (in React)

Ohans Emmanuel

Discover the power of Server Components in React without the need for a framework. In this workshop, we will explore how to build a server-side rendering solution using "only" vanilla JavaScript and Node.js. We'll dive into the core concepts of Server Components, including how to render components on the server and manage data fetching. By the end of this session, you'll have an understanding of how to implement Server Components in your own projects without relying on a framework.

From Zero to Streaming: Implementing React Server Components Yourself

Krasimir Tsonev

Many developers believe seniority is something that happens automatically with time. In practice, some engineers repeat the same year of experience for a decade, while others grow rapidly by changing how they approach problems, people, and responsibility. This talk explores the mindset and behaviors that define effective senior engineers. The content is drawn from real industry experience and consolidated into the book "Pocket Guide to Seniority", turning years of lessons, failures, and team dynamics into practical guidance. We will cover themes such as seeing the whole picture beyond your ticket, owning outcomes instead of outputs, choosing simplicity over cleverness, managing ego in technical discussions, and multiplying impact through teaching. Each topic comes with concrete examples from real projects and teams, focusing on decisions and behaviors rather than abstract theory. Attendees will leave with actionable mental models they can apply immediately in their daily work, regardless of tech stack or company size.

Pocket Guide to Seniority

Should we be using a state management library to toggle dark mode? Do we really need a custom hook for opening an accordion? And how many event listeners is too many when animating on scroll? React gives us an incredibly powerful way to build UI, but not every UI behaviour needs React level machinery. In this talk, we’ll take a look at how to use HTML and CSS to build simpler alternatives to common interactive components such as accordions, modals, scroll transitions, carousels etc We’ll also take a look at the performance and accessibility benefits and real-life applications and use-cases of these components.  The goal is to simplify how we handle content, display and animation using native browser features and leaving React to do what it's best at: everything else.

Your React App Doesn't Need All That JavaScript

Jemima

Building a global product using React is not just about translating UI to code; it’s about architecting for localization, multi-tenancy, compliance, and market-specific behaviors. Leading architecture at Gopaddi, we’re scaling a travel operating system that serves users across continents, each with unique currencies, policies, suppliers, and regulations. In this talk, I’ll share how I architect our applications to adapt dynamically, whether that’s region-based routing, currency-aware UI flows, or market-specific feature toggles. You’ll see patterns for managing complexity without fragmenting the codebase, and lessons on balancing scalability, performance, and developer experience in global-scale React systems.

Global-Scale React: Architecting for Localization, Multi-Tenancy, and Dynamic Markets

Ayodele Aransiola

Hello, dear friend, I trust this message reaches you in excellent spirits. I write to you not only as a humble developer, but as the sole surviving heir of an ancient lineage of engineers whose wisdom has been carefully safeguarded through centuries. With great urgency, I invite you to transfer a modest administrative fee to the secure digital vault. In return, you shall gain access to an extraordinary fortune of technical insight. This privileged knowledge includes the steps required to craft a complete Newsletter system using React and MDX, as well as the instructions needed to dispatch your first email with Resend. Your generous cooperation will open the gates to revelations about the Newsletter Architecture, rendering emails on the web, layout traps in different email clients, automation with CI/CD, and those unsuspecting details that have bankrupted many brave developers before you. I remain eternally grateful for your imminent collaboration.

FWD: Urgent Opportunity to Claim Your React + MDX Newsletter Inheritance

César Alberca

Stephen explains how AG Grid implemented an abstraction layer that allows component libraries to target multiple frameworks, using the framework's native rendering, and without requiring framework-specific code for each feature.

Framework Native Rendering Without Code Duplication?

Stephen Cooper

In 2026, shipping a heavy library like Formik or React Hook Form is often an unnecessary performance tax. This "delete code" session showcases how to use the Constraint Validation API, the Popover API, and native HTML Form Validation to build complex, accessible, and high-performance forms with zero external dependencies. We will compare the bundle size and TBT (Total Blocking Time) of a "library-less" form versus a traditional one, proving that "doing less" is the ultimate developer experience.

Replacing Form Libraries With Native Web APIs

Trust Jamin

ARIA, the Accessible Rich Internet Applications Suite, is a huge topic and full of hard concepts. Learning it becomes even more intimidating when you hear "the first rule of ARIA is don't use ARIA". This common adage doesn't mean ARIA will literally never make your webpage more accessible. Let's talk about what it really means.

What the First Rule of ARIA Really Means

Abbey Perini

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 &lt;Activity /&gt; 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 often gets blamed when applications feel sluggish."We need to migrate." "We need a new framework." "React can’t handle scale." But what if React isn’t the problem? In this talk, we’ll challenge one of the most common assumptions in frontend engineering: that the framework is responsible for poor performance. Through real-world production patterns and architectural examples, we’ll uncover what actually breaks as applications scale - and why most performance issues stem from our decisions, not React itself. We’ll explore how over-rendering, global state misuse, network waterfalls, third-party script bloat, and poorly applied SSR strategies quietly degrade performance long before React becomes a bottleneck. This session is not about micro-optimizing hooks. It’s about thinking like a frontend architect.

Scaling React: What Actually Matters

Tathagat Thapliyal

Every modern app starts from the same truth: your website is built on data. Traditionally, developers define how that data turns into UI - the f in UI = f(data, state). But every user approaches your app with different goals, contexts, and focus, and a one-size-fits-all interface forces them to work around the UI instead of it working for them. In this talk, we’ll explore the Generative Front-End - a new paradigm where the logic that maps data to interface is itself generated by an LLM. We’ll see how React Server Components and Server Functions make this pattern possible natively, without hacks or ad-hoc APIs. The result: interfaces that adapt to the user, the data, and the moment - where developers design the system that builds the screens.

The UI That Builds Itself: Exploring the Generative Front-End

Kiril Peyanski

How do you scale a React UI system from Smart TVs to refrigerators, washing machines, and more while keeping everything consistent? This talk shares our real-world experience extending a React-based UI component system (initially built for webOS TV) into a multi-platform design system in collaboration with Figma. Moving beyond traditional handoffs, you will learn how we connected design and development to "design once and scale everywhere" using a robust Design Token architecture, CI/CD automation, and an AI workflow that leverages the Figma MCP to generate exact component code.

From Figma to TV & Beyond: Scaling React UI with Design Tokens & MCP

“Write once, run everywhere” is a promising goal in software development, but one that often breaks down under real-world compatibility problems. At Zattoo, building streaming applications across Android, Apple, and Web meant years of separate native stacks that were not aligned, and therefore did not scale. This talk explains how moving to a multiplatform architecture, enabled by Vega as a fourth, React Native first platform, brought us very close to achieving that goal.

The Fourth Platform: How Vega Got Us Surprisingly Close to “Write Once, Run Everywhere”

We will explore how attackers steal browser cookies and session data, even with modern protections in place. The session showcases real-world techniques used in post-exploitation to extract sensitive information. It highlights the need for developers and defenders to understand browser internals and encryption to stay ahead of threats.

Protecting Your Cookies from Hackers and Hungry Developers!

Mohamad Shiralizadeh

It’s entirely possible to be a strong frontend engineer while remaining mostly oblivious to availability, SLAs, SLOs, and delivery metrics. Many teams are structured that way, and it works, until you want to increase your impact beyond the UI. This talk is about expanding the frontend perspective to include the system it lives in. Not to turn frontend engineers into SREs or platform specialists, but to build full-stack awareness that leads to better decisions, safer changes, and healthier delivery practices. We’ll look at resilience as a mindset across the software development lifecycle, and how practices like atomic changes, trunk-based development, feature flags, and automated rollbacks directly affect frontend work, even when the failures don’t originate in the UI. We’ll also connect these practices to availability targets, SLOs, and DORA metrics, and explain why failure tolerance is contextual, from highly regulated systems with near-zero tolerance to products where controlled failure is acceptable. The goal is to help frontend engineers understand how their work fits into the larger system, so they can ship faster, reduce risk, and increase their impact within a team without losing focus on frontend excellence.

Designing for Failure: The Senior React Dev's Production Toolkit

Faris Aziz

<div>Many front-end developers build modern applications with confidence, but struggle when it comes to shipping those applications to production. Docker, CI/CD, environment configuration, performance tuning, and deployment often remain “someone else’s job” — until something breaks and becomes your responsibility. This workshop closes that gap. It’s a practical, production-focused workshop designed for front-end developers who want to take full ownership of their front-end applications — from local development to stable, production-ready deployments. You’ll learn how to: </div><ul><li>Dockerize front-end applications for both development and production</li><li>Create optimized, production-ready Docker images for modern front-end frameworks</li><li>Optimize front-end applications for performance, stability, and reliability</li><li>Avoid common production mistakes seen in real-world front-end projects</li></ul>Docker for Front-end Developers is a practical book designed specifically for front-end engineers who want to truly understand and confidently use Docker in real-world projects — written by Docker Captain and author of the official Docker React.js sample documentation Kristiyan Velkov — with 30% off using code DOCKER30.

DevOps for Front-end Developers: From Local Code to Production by Docker Captain

Kristiyan Velkov

By 2025, our React and React Native apps were struggling with inconsistent APIs, causing bugs, duplicated work, and slow onboarding. We adopted a schema-driven workflow with OpenAPI, generating type-safe TypeScript clients and enabling AI-assisted development of hooks, components, and tests. This talk shares our real-world lessons, practical strategies, and incremental approach to ship features faster and more reliably across web and mobile.

Stop Guessing Your API: Contract-First React with OpenAPI

Violina Popova

The web comes accessible out of the box, we just need to know how to use it. With modern advancements in HTML, CSS, and even JS, the tools to build an inclusive experience are more powerful than ever.  More accessibility means increased usability for everyone, so let’s explore these new tools and best practices, and how they can help us create a better and inclusive web.

The Web is Your A11y — Building Accessible Web Apps By Using the Platform

Julian Burr

We all know React as the community favorite library for developing web and mobile but what about devices on the edge? Edge/Embedded devices have significant restrictions on resources (memory, disk space, and compute) but that doesn't mean React can't be deployed to them. In this talk we'll discuss some tips and tricks you can use to develop and deploy applications to edge devices. Even if you are not developing applications for the edge you'll walk away from this talk knowing how to decrease the resource usage of your React applications.

React on the Edge

Ameer Sami

Images are often shipped with the wrong dimensions, wrong format, and no optimization for the layout they sit in. In this talk, we start from a broken React e-commerce page using the ImageKit SDK, use the Chrome DevTools MCP server to audit real network requests and identify performance issues, then let AI use ImageKit to apply the fixes directly in code. A practical, live look at what an agentic developer workflow looks like when it's actually solving something real.

I Did Everything Wrong So You Don't Have To

Angel Pichardo

React applications often assume predictable environments — stable networks, ordered responses, and linear state transitions. But real-world systems don’t behave that way. What happens when your React app communicates with something unreliable — streaming data, AI pipelines, background processes, or hardware devices that disconnect without warning? In this talk, I’ll share a production case study of architecting reliable React Native systems in highly asynchronous environments. Using Bluetooth communication as an extreme stress test, we’ll explore how to design deterministic state transitions, prevent race conditions, avoid retry storms, and keep UI truth aligned with external system reality. This session focuses on architecture and reliability patterns — not just libraries — and offers practical strategies for building resilient, production-grade React systems when the world outside your UI refuses to behave.

Architecting Reliable React Systems in Unreliable Environments

React and your browser DevTools are excellent, but they stop where your business logic begins. This talk shows how I built a custom, team-specific DevTools that expose proprietary state, domain events, and hidden system behavior, giving engineers real visibility into complex React applications.

Debugging What React DevTools Can’t See

Vishnudhasan Govindarajan

One of the exciting things about web development is that the underlying technology that we use is constantly evolving. It’s hard to believe, but Server Components, partial hydration and hybrid rendering are no longer experimental features and are here to stay. With more projects adopting these newer patterns for client side rendering, the challenge now is to ensure that these applications can scale and that there are not new performance and reliability challenges that have not yet been fully considered. We’ve begun to encounter a wide range of new issues that include hydration behavior that doesn’t work the same way every time, rendering waterfalls, delayed streams and more, as well as some of the more subjective performance regressions. So you’ve built this amazing React app, and now it’s time to deploy it to production. But what actually happens when you type in your username and password and hit submit? Let’s take a closer look and skip all the boring parts about React and focus on the low level details of what’s actually happening and how the browser turns your state into pixels on the screen. We’ll get into why hydration mismatches happen and how to figure out why they’re happening to you. And finally, we’ll look at some actual tools and techniques that you can use in your app to improve the user experience, squash weird rendering bugs and make hybrid rendering easier to understand and manage.

Real-World Hydration and Rendering Patterns in Modern React Apps

Raju Dandigam

In this hands-on workshop, you’ll learn how to integrate AI directly into your application using TanStack AI. We’ll build a working AI chat feature end-to-end, starting from server setup and finishing with a streaming client, tool calling, human-in-the-loop workflows, and real debugging using TanStack DevTools. Through guided exercises, you’ll learn how to set up TanStack AI on the server, connect a client application to a streaming AI backend, build a functional chat interface, create your first AI tools, and implement approval flows so humans can stay in control when tools are invoked. By the end of the session, you’ll understand the core building blocks of AI-powered applications and walk away with a solid foundation for adding intelligent chat and tool capabilities to your own apps. Workshop outcomesWhen you're finished with this workshop you will:<ul><li>Understand how to set up TanStack AI on the server and wire it to a provider (like OpenAI)</li><li>Know how to connect a client app to a streaming AI endpoint and handle incremental updates cleanly</li><li>Build a functional chat UI with a solid state model for messages, streaming tokens, and tool results</li><li>Create and use your first AI tools with clear inputs, outputs, and predictable behavior</li><li>Build human-in-the-loop workflows with tool approvals so your app can ask for confirmation before executing sensitive actions</li><li>Debug and inspect your AI app using TanStack DevTools, including tool calls, responses, and streaming behavior</li></ul>What you'll learn TanStack AI gives you the primitives to build real AI features, not just a demo prompt box. This workshop focuses on wiring everything together properly, from server-side streaming to client UX, then layering in tools, approvals, and debugging so the final result is something you can confidently evolve into production features. You’ll learn the following through these exercises:<ul><li>Server setup - Configure TanStack AI on the server, connect to your model provider, and expose endpoints that support streaming chat</li><li>Streaming and SSE - Implement and consume streaming responses, understand the lifecycle of a stream, and build UI that stays responsive while tokens arrive</li><li>Chat UI and state - Build a chat interface that handles message history, partial responses, loading states, and tool outputs in a clean way</li><li>Tools - Define tools, validate inputs, return structured outputs, and integrate tool results back into the conversation flow</li><li>Human in the loop - Add approval steps for tool execution, implement “approve/deny” flows, and keep users in control when actions matter</li><li>Debugging with TanStack DevTools - Inspect requests, responses, tool calls, timing, and streaming behavior so you can troubleshoot fast and iterate safely</li></ul>Prerequisites This workshop assumes you can build and run a React + TypeScript app locally and you are comfortable working with a basic server setup.<ul><li>Basic understanding of SSE and streaming is required (we’ll use streaming heavily throughout the workshop)</li><li>Experience with React is required (components, state, props, rendering lists)</li><li>Basic TypeScript knowledge is required (we’ll rely on types for tools and structured outputs)</li><li>You will need an OpenAI API key with available credits to use during the workshop exercises</li></ul>

Building AI-Powered Apps with TanStack AI - From Setup to Chat Tools

Alem Tuzlak

How can you create performant animations, backed by fast-updating data, on the web, using React? Come learn how to make silky-smooth data-powered animations without having to give up the convenience of React. (Mostly…) React is great for manipulating the DOM, but all that shadow DOM logic can bog down data-powered animations and slow down sites. There’s a trick to getting it right (and, spoiler alert, some of it’s not React). We’ll go through a real-world case-study and along the way, learn about: - how to get data from the backend to your frontend mega-fast - why requestAnimationFrame beats setInterval hands down - the power of HTML Canvas for web-based animation Come see how fast React can be!

Gotta Go Fast: React at 60 FPS

Rachel Kaufman

I am 19 years old with a 9.4/10 GPA in CS, but university is not my priority. It is my side hustle. My real job is operating as a Founding Engineer. In this talk, I challenge the "Learn then Do" path and share the "Gen Z Builder" blueprint: how I use Next.js, AI agents, and extreme context switching to ship production apps while acing exams.

University is My Side Hustle: How Gen Z Builders Ship to Production

Artemis Leonardou

<div>After 25 years building for the web, I built rari—a React Server Components framework on Rust that delivers 45x higher throughput than Next.js. This talk is about the architecture decisions that made it possible.</div><div> </div><div>I'll walk through the three-layer architecture: a Rust runtime with embedded V8, RSC-aware Vite transformations, and true streaming SSR. You'll see why using V8 directly through Rust (not Node.js) changes everything, how correct 'use client' and 'use server' semantics matter more than expected, and what I got fundamentally wrong in my first implementation.</div><div> </div><div>When I fixed three pieces—app router support, true SSR, and correct RSC semantics—performance jumped from 4x to 45x. Not because Rust is inherently fast, but because the architecture finally matched React's design intentions.</div><div> </div><div>You'll learn concrete patterns for RSC streaming at the runtime level, trade-offs between ecosystem compatibility and performance, and how React Server Components actually work under the hood. No Rust experience required—just curiosity about what's possible when you rethink the runtime layer.</div>

Building RSCs Framework on Rust: Architecture Decisions That Delivered 45x Performance

Ryan Skinner

Modern React tooling keeps improving, yet many teams still struggle with performance regressions that appear months after launch. This talk explores common React patterns that look correct early on but quietly degrade performance as applications grow, and how to reason about them before they become costly to fix.

React Performance Patterns That Break Down in Long-Running Production Apps

Himanshu Srivastava

We’ll dive into proven methods for building and sustaining high-performing remote teams. You’ll gain insights into maintaining seamless communication, promoting a positive team culture, and using the right tools for project success. We’ll also tackle the common hurdles, such as time zone coordination, maintaining code quality, and keeping team engagement high. Walk away with practical solutions and strategies that you can implement immediately to enhance your team’s remote collaboration.

Effective Strategies for Managing Remote Frontend Teams

Martin Asenov Mladenov

Have you ever been handed a React project that felt like navigating barbed wire? 900-line components, endless useEffects, and zero modularity. Join me as we take a real-world React nightmares and refactor it live! We’ll move from an over-engineered mess to a performant, scalable app by mastering predictable state management, centralized data handling, and domain-driven structure. Leave the “mess” behind and learn how to build React components that bring order back to your code!

Mess to Modern: Refactoring a React Nightmare

Kaleb Garner

When React 18 was released with the first concurrent features, the documentation clearly stated, “The most important addition in React 18 is something we hope you never have to think about: concurrency.” It’s been a few years, and by now it’s clear that this statement was optimistic. You definitely need to think about concurrency if you want to unlock the full potential of modern React features. In this deep-dive session, we’ll travel between several domains—from classic computer science theory and operating systems to UX and user psychology—before finally deep-diving into React’s reconciler over the years. By the end of this session, you can expect to have a deep understanding of React’s concurrent features—from Suspense and useTransition to useDeferredValue and the brand-new Activity component.But more important than understanding these specific features is obtaining the theory and knowledge to understand any future concurrent features as they are released.

Conquering React Concurrency

Ariel Shulman

Most React applications treat state as the single source of truth. But what happens when time itself lives outside React? While building a production multi-track timeline engine, we discovered that the Web Audio transport, not React state had to become the canonical timeline. In this talk, we will explore how we designed a channel-based audio graph and canvas-rendered editor around an external high-precision clock, enabling deterministic synchronization of externally generated audio and media, 60fps rendering, and zero-reload state updates without letting React’s reconciliation interfere with real-time guarantees.

React vs. Real-Time: Build Real-Time Features Without Fighting the Framework

Shubham Gautam

SPAs were always based on contingent logic. For the benefits to materialise, users must spend a great deal of time in the same interface, updating state in-place. This never described the majority of experiences, where very little is persisted across screens and critical user journeys. As the industry moves away from SPAs and the frameworks they popularised, one of the largest hurdles for teams rethinking their approach is retaining the trust of managers who previously signed off on the very SPAs that now feel slow and shabby. Getting management on board with View Transitions isn't just a technical hurdle, it's an organisational journey. This talk boils down the types of evidence and approaches that help senior leaders develop confidence in the new analysis, making the post-React world feel attainable.

Building Bridges to a Post-SPA Future

 Alex Russell

Every team building with AI faces the same tension: move fast and ship, or slow down and get it right. At Zed, we build an IDE obsessed with performance and quality. This means being brutally honest about where AI helps, where it hurts, and how we make decisions when the answer isn't obvious. This is the story of how we navigate that tension in practice — the tradeoffs, the mistakes, and the framework we've built for keeping quality alive when speed is the default.spectrum of dev workflows. All while being fully obsessed with quality, speed, and performance.

Speed, Quality, and AI: You Can't Have It All (Or Can You?)

Gaauwe Rombouts

AI has made building software faster, but it has also quietly changed the environment engineers are operating in. Responsibility hasn’t disappeared; it has concentrated. Decisions are harder to trace, failures are harder to localize, and humans remain accountable inside systems they no longer fully control.Drawing from experience designing systems for extreme environments, where visibility is limited, failure cascades, and human limits must be designed for, this talk reframes AI-assisted development as an operational challenge, not a tooling one. It introduces a different lens: treating AI-driven systems as architecture that must be operated like extreme environments, instead of faster versions of normal ones.

Operating at the Edge: What Extreme Environments Teach Us About AI Systems

Michal Ziso

Integrating Firebase into a modern React stack often feels like a tug-of-war between server and client state. Juggling the appropriate SDK, managing rehydration flickers, and handling session management can make our "simple" SDK complex. Dive into battle-tested patterns and the latest SDK features to help you bridge the gap between the server and the client seamlessly.

Taming the Flicker: Firebase Patterns for React Server Components

James Daniels

All it takes is a module and a CLI tool to build and deploy production peer-to-peer applications.In this workshop:<ul><li>Convert an existing React application so that it no longer needs a server to deploy</li><li>Prepare the application and setup deployment flow for production release</li><li>Go to production with multisig - decentralized quorom-based cryptographic signoff gated releases</li></ul>This is for anyone who builds with React or JavaScript and anyone who deploys applications.

No Servers, No Cloud, No Masters: Make P2P Apps with Pear

David Mark Clements

In this React testing workshop, we’ll trade fragile testing strategies for a testing recipe that actually holds up under pressure. If your current strategy feels like reheated leftovers — mocks that prevent you from refactoring, flaky end-to-end tests, or last-minute releases served raw — it’s time to sharpen your knives. We’ll hit the market for fresh ingredients like Vitest, Testronaut, Fakes, and Object Mothers. Then, back in the kitchen, we’ll prepare low-maintenance, high-confidence tests that stay crisp through refactors and migrations. No dogma, no silver bullets — just practical, battle-tested techniques to help you cook with confidence.

Pragmatic Testing Recipes: Crafting Tests That Survive the Heat

Over the past year, model intelligence has skyrocketed, and agent tooling has improved significantly. However, there's still a gap: most AI agents don't have the procedural, domain-specific expertise needed to do real work inside real products, especially in React apps, where a small behaviour change turns into user-facing regressions. In this workshop, I'll show how leveraging Agent Skills changes how you build AI features in React: from prompt tweaking to shipping packaged guides, resources and scripts that turn a general-purpose agent into a product-specific one via the Agent Skills protocol.  I'll be showing a practical way to do this in React apps without changing your current frameworks or LLM, with evals and versioning in place to prevent regressions.

How to Build Reliable AI Agents with Agent Skills (in React)

Direct the code. Don't just write it.The development landscape is shifting from manual coding to system orchestration. Whether you are a seasoned React engineer looking to 10x your output or a product-driven creator aiming to turn a prototype into a functional app, this workshop is your gateway to AI-native development.Join us for a hands-on, 4-hour masterclass where we build a feature-rich, fullstack application from scratch using Cursor Composer. We skip the boilerplate and focus on the exact workflows used to ship high-quality features in minutes, not days.What You’ll Master<ul><li>AI Orchestration: Move beyond simple autocomplete to manage multi-file changes and complex app logic.</li><li>The .cursorrules Framework: Learn how to enforce project standards and prevent AI "hallucinations" for consistent, professional code.</li><li>Rapid Fullstack Scaffolding: Generate type-safe database schemas and backend logic instantly.</li><li>High-Fidelity UI Iteration: Transform prompts into polished, responsive interfaces using modern CSS and component libraries.</li><li>Hardening &amp; Refactoring: Use AI to hunt bugs, clean up "spaghetti" code, and generate comprehensive test suites.</li></ul>The ProjectWe will build a modern, data-driven web application that demonstrates the power of AI-assisted development. By the end of the session, you will have a functional codebase that showcases complex data relationships, dynamic UI, and optimized state management. Who Is This For?Developers who want to eliminate repetitive tasks and focus on high-level architecture.Founders &amp; Prototypers who need to bridge the gap between an idea and a working product rapidly.Tech Enthusiasts eager to master the professional AI-native toolkit.Requirement: Bring a laptop with Cursor installed. We provide the roadmap; the AI provides the speed; you provide the vision. As this is a live online session, we encourage you to sign up ASAP to receive the pre-workshop setup guide and ensure you are ready to build from minute one.

Building Fullstack Apps with Cursor

Maurice de Beijer

A new ecosystem of apps is emerging inside generalist conversational agents like ChatGPT and Claude. These apps serve as a direct digital storefront for brands. They serve as a compelling alternative to traditional mobile and web applications for the billion users who now begin their online journey in a chat. AI apps are built on standards like Apps SDK, MCP Apps, and MCP UI. They all rely on MCP as the underlying protocol to expose context and tools, while adding a human-facing presentation layer in the form of UI widgets. Building these React apps introduces a genuinely new set of challenges: you're no longer designing for a user interacting with a UI alone, but for a three-way dynamic between a human, a UI, and a model. Every interaction must account for whether it originates from a click on a widget or a message typed in the chat. Skybridge is the full-stack TypeScript framework built on React that we created at Alpic to help developers around the world ship these new apps at the speed of light. Come and learn how to build the next generation of AI apps with me!

React Summit 2026

The biggest React conference worldwide