Explore upcoming talks from events
JS GameDev Summit 2023
JS GameDev Summit 2023
Sep 28 - 29, 2023
Node Congress 2024
Node Congress 2024
Apr 4 - 5, 2024
C3 Dev Festival 2024
C3 Dev Festival 2024
Jun 14 - 15, 2024
React Day Berlin 2024
React Day Berlin 2024
Dec 13 - 16, 2024
React Summit 2026
React Summit 2026
Jun 11 - 16, 2026
AI Coding Summit London
AI Coding Summit London
Jul 6 - 7, 2026
React Advanced 2026
React Advanced 2026
Oct 23 - 26, 2026
JSNation US 2026
JSNation US 2026
Nov 16 - 19, 2026
AI Coding Summit NYC
AI Coding Summit NYC
Nov 16 - 19, 2026
React Summit US 2026
React Summit US 2026
Nov 17 - 20, 2026
React Day Berlin 2026
React Day Berlin 2026
Dec 4 - 7, 2026
Talks
Showing 100 talks
Panel Discussion: What's the big next step for Vue/Nuxt?
Vue.js Live 2024Vue.js Live 2024
43 min
Panel Discussion: What's the big next step for Vue/Nuxt?
Eduardo San Martin Morote
Maya Shavin
Konstantin BIFERT
Daniel Roe
Alexander Lichter
5 authors
We're focusing on performance improvements, both in build and development time. Additionally, we're exploring the use of WASM for deploying binaries into production. WASM is great for performance. Data loader is also important. The target audience for the podcast is Vue developers, including middle to senior developers. The podcast aims to provide new and advanced topics, including features, examples, use cases, and inspiring stories. Podcasts are complex without screen sharing, but videos can provide more in-depth content. Nuxt will be interesting to see. VaporMode in Vue enables performance through built-time transforms. The merging of Wiz and Angular brings core primitives and resumable components. Nuxt community is focusing on performance. The Vue router has an open issue with many routes. Legacy issues with ESM and TypeScript cause pain for maintainers and consumers. Node and the required ESM are exciting. Accessing Cloudflare primitives in development. Micro frontends have a shell with multiple frontends and require a general store. Web components have shown promise, but there are pain points. Mitosis and ReactiveView are alternative solutions. Web components are the best way to adhere to browser standards, but they may have limitations. Nuxt has seen successes despite the limitations of web components. Nuxt 3 has invisible improvements and a good developer experience. The migration from Nuxt 2 to 3 had communication challenges. The Talk will resume after a short break.
React on the Edge
React Summit 2026React Summit 2026
17 min
React on the Edge
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 Performance Patterns That Break Down in Long-Running Production Apps
React Summit 2026React Summit 2026
20 min
React Performance Patterns That Break Down in Long-Running Production Apps
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.
Protecting Your Cookies from Hackers and Hungry Developers!
React Summit 2026React Summit 2026
27 min
Protecting Your Cookies from Hackers and Hungry Developers!
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.
University is My Side Hustle: How Gen Z Builders Ship to Production
React Summit 2026React Summit 2026
15 min
University is My Side Hustle: How Gen Z Builders Ship to Production
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.
Architecting Reliable React Systems in Unreliable Environments
React Summit 2026React Summit 2026
34 min
Architecting Reliable React Systems in Unreliable Environments
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.
Global-Scale React: Architecting for Localization, Multi-Tenancy, and Dynamic Markets
React Summit 2026React Summit 2026
14 min
Global-Scale React: Architecting for Localization, Multi-Tenancy, and Dynamic Markets
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.
Debugging What React DevTools Can’t See
React Summit 2026React Summit 2026
22 min
Debugging What React DevTools Can’t See
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.
Stop Guessing Your API: Contract-First React with OpenAPI
React Summit 2026React Summit 2026
29 min
Stop Guessing Your API: Contract-First React with OpenAPI
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.
The Fourth Platform: How Vega Got Us Surprisingly Close to “Write Once, Run Everywhere”
React Summit 2026React Summit 2026
31 min
The Fourth Platform: How Vega Got Us Surprisingly Close to “Write Once, Run Everywhere”
“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.
React vs. Real-Time: Build Real-Time Features Without Fighting the Framework
React Summit 2026React Summit 2026
20 min
React vs. Real-Time: Build Real-Time Features Without Fighting the Framework
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.
Replacing Form Libraries With Native Web APIs
React Summit 2026React Summit 2026
17 min
Replacing Form Libraries With Native Web APIs
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.
Operating at the Edge: What Extreme Environments Teach Us About AI Systems
React Summit 2026React Summit 2026
19 min
Operating at the Edge: What Extreme Environments Teach Us About AI Systems
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.
Gotta Go Fast: React at 60 FPS
React Summit 2026React Summit 2026
16 min
Gotta Go Fast: React at 60 FPS
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!
Mess to Modern: Refactoring a React Nightmare
React Summit 2026React Summit 2026
18 min
Mess to Modern: Refactoring a React Nightmare
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!
Scaling React: What Actually Matters
React Summit 2026React Summit 2026
30 min
Scaling React: What Actually Matters
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.
Conquering React Concurrency
React Summit 2026React Summit 2026
25 min
Conquering React Concurrency
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.
FWD: Urgent Opportunity to Claim Your React + MDX Newsletter Inheritance
React Summit 2026React Summit 2026
19 min
FWD: Urgent Opportunity to Claim Your React + MDX Newsletter Inheritance
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.
From Figma to TV & Beyond: Scaling React UI with Design Tokens & MCP
React Summit 2026React Summit 2026
17 min
From Figma to TV & Beyond: Scaling React UI with Design Tokens & MCP
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.
React Bits: The Art of Standout UI
React Summit 2026React Summit 2026
21 min
React Bits: The Art of Standout UI
Effective Strategies for Managing Remote Frontend Teams
React Summit 2026React Summit 2026
19 min
Effective Strategies for Managing Remote Frontend Teams
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.
Skills in Claude Code Desktop: Architecture and Execution Runtime
React Summit 2026React Summit 2026
25 min
Skills in Claude Code Desktop: Architecture and Execution Runtime
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.
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.
Pocket Guide to Seniority
React Summit 2026React Summit 2026
25 min
Pocket Guide to Seniority
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.
Modernizing Your React App: Compiler, useEffectEvent, Activity & Friends
React Summit 2026React Summit 2026
27 min
Modernizing Your React App: Compiler, useEffectEvent, Activity & Friends
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 <Activity /> 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
Software Craftless: Writing Code That Would Make a Goat Vomit
JSNation 2026JSNation 2026
15 min
Software Craftless: Writing Code That Would Make a Goat Vomit
Most technical talks teach you how to write clean, scalable, maintainable code. This one does not. Here you will learn how to write code that confuses, deceives, and breaks things in unexpected ways... on purpose. And on top of that, in JavaScript.Discover how to:Hide bugs so well that even you cannot find themCreate features that break just by looking at themDesign programs that only work on your local machineDevelop functions that return anxietyImplement code structures that are illegal in 42 countriesBecause if nothing and no one understands your code... they cannot fire you. This is the talk you did not know you needed. Join me, and together we will write code so twisted it would make a goat throw up. 
LLM Powered Migration of UI Component Libraries
Web Engineering Summit 2026Web Engineering Summit 2026
25 min
LLM Powered Migration of UI Component Libraries
Code migrations are repetitive, time-consuming, and tools like codemods struggle to handle complex transformations without extensive manual effort. What if there was a smarter way to tackle large-scale migrations? In this talk, we explore how LLMs can take the heavy lifting out of such complex code migration and share practical learning and insights.
Rewrite or Refactor? How to Safely Move Legacy Apps to Modern Frameworks
JSNation 2026JSNation 2026
21 min
Rewrite or Refactor? How to Safely Move Legacy Apps to Modern Frameworks
Sooner or later, every team faces the same question: how do we migrate from legacy code to a modern framework? Should we take the “big bang” approach and rewrite everything from scratch, or should we migrate progressively, piece by piece? In this talk, I’ll share real-world stories from large-scale frontend migrations and highlight the trade-offs of both strategies. We’ll explore the risks of freezing development for months, the complexity of running two worlds in parallel, and the decision-making criteria that help teams pick the right path.
Supercharging Your Tooling With Rust
JSNation 2026JSNation 2026
24 min
Supercharging Your Tooling With Rust
Yarn is the latest tool to join the Rust revolution. But is rewriting JavaScript tooling in Rust a necessity or just a trend? In this talk we'll dive into Yarn's recent updates to understand why they made the switch and how it went. We will discuss whether a fully Rust-based toolchain is inevitable and, crucially, what role Node.js will play in this new landscape.
Stop Using JSON Web Tokens (JWTs) for Authorization!
Web Engineering Summit 2026Web Engineering Summit 2026
12 min
Stop Using JSON Web Tokens (JWTs) for Authorization!
JWTs (JSON Web Tokens) are everywhere – frontends, backends, microservices – and for good reason: they're easy to pass around, self-contained, and standardized. But while JWTs can be a solid fit for authentication, using them for authorization is a decision that comes with serious pitfalls – especially in distributed systems.In this talk, we’ll explore the technical and security limitations of JWT-based authorization and explain why they're fundamentally incompatible with the needs of modern applications. From the infamous ""New Enemy Problem"" described in Google’s Zanzibar paper to the vague semantics of scope claims and the difficulty of revoking tokens in-flight, we’ll unpack the real-world consequences of treating JWTs as your AuthZ layer.
Halving Your CI Pipeline – Practical Optimisation Strategies
JSNation 2026JSNation 2026
10 min
Halving Your CI Pipeline – Practical Optimisation Strategies
Every minute added to your CI pipeline costs real money and real developer time. At ~45 MRs per day and ~340 pipeline runs, a single minute of pipeline overhead translates to nearly 6 hours of lost engineering time daily. This talk presents the complete playbook we used to reduce our Merge Train pipeline from about an hour to about 22 minutes — a ~64% reduction — while improving CI health from the low 80s to the low 90s percent. Covering compute instance migration (with real benchmark data from 10 runs per configuration), service test extraction, CloudWatch optimisation, linter caching, flaky test detection, and cost analysis, attendees leave with a prioritised framework for their own CI optimisation efforts. Every optimisation includes before-and-after metrics, cost impact, and the trade-offs we navigated.
Think Like a Tester: What to Look For in AI-Generated Code
JSNation 2026JSNation 2026
16 min
Think Like a Tester: What to Look For in AI-Generated Code
AI is writing code faster than ever. But there's a gap: the gap between "it works" and "it works correctly."As a QA Automation Engineer with 9 years of experience, I've developed the instinct to see what breaks before it breaks. AI generates clean code that hides catastrophic bugs in plain sight. This talk teaches you "the tester's eye" – the ability to spot edge cases, boundary conditions, state issues, and silent failures that AI confidently creates.You're reviewing AI code with developer eyes trained to see "does this solve the problem?" Testers see something different: "what are all the ways this could fail?" I'm teaching you to see both.
De-bloating the Web: The "Ecosystem Performance" Initiative (e18e)
JSNation 2026JSNation 2026
20 min
De-bloating the Web: The "Ecosystem Performance" Initiative (e18e)
Join the "Ecosystem Performance" initiative to explore our mission to revolutionize the JavaScript ecosystem. We tackle bloated, slow, and outdated dependencies in popular open-source libraries, replacing them with optimized alternatives or crafting our own superior solutions. Our goal is a faster, more secure web, enhancing the developer experience by reducing node_modules overhead and improving overall efficiency. Discover what we've achieved so far, our ongoing efforts, and how you can contribute to shaping a leaner, more performant future for web development.
From Legacy to Delight: The Future of Node.js DX
JSNation 2026JSNation 2026
21 min
From Legacy to Delight: The Future of Node.js DX
For over a decade, Node.js documentation relied on legacy tooling, despite being the critical source of truth for @types/node, Bun, Deno, and AI models. In this talk, we unveil the engineering behind @nodejs/doc-kit – the modular successor to Node’s documentation engine. Discover how we parse massive ASTs and leverage modern Web Standards to solve complex rendering and accessibility issues, creating a high-performance experience designed to delight humans and power the ecosystem.
Taking a Dump: Using Heap Dumps to Find and Fix NodeJS Memory and CPU Problems
Web Engineering Summit 2026Web Engineering Summit 2026
22 min
Taking a Dump: Using Heap Dumps to Find and Fix NodeJS Memory and CPU Problems
JavaScript uses Garbage Collection (GC) for memory management. As a result, many developers that use JavaScript based systems, such as NodeJS, assume that they’re free of memory issues. Unfortunately this is incorrect, and many NodeJS-based services suffer from memory management problems such as leaks and excessive GC CPU cost. But finding, understanding, and resolving memory issues can be very challenging, because a problem in any part of the application impacts the application as a whole. Also, they may only manifest under load, in production environments. In this session I will explain how to find and fix such issues using the heap dump feature that is built into NodeJS. And I will show how to use the DevTools memory panel to analyze such dumps.
Black Friday: Would You Choose the Right Performance Test?
Web Engineering Summit 2026Web Engineering Summit 2026
16 min
Black Friday: Would You Choose the Right Performance Test?
Black Friday is one of the most challenging times for any system, as traffic can increase by four to ten times within a short period. Teams often prepare by running performance tests, but they may not be using the right testing method.In this talk, I will present a real-life situation where a system seems fine during testing but crashes when faced with actual conditions.The main problem isn't the system itself, but the way the test was set up.This topic is especially important for teams developing and expanding web applications, especially during high-traffic events like Black Friday.It bridges the gap between performance testing strategies and real-world system performance, while also considering business impact.
Templates and Components for Claude Code: The Future of AI Coding Workflows
Web Engineering Summit 2026Web Engineering Summit 2026
30 min
Templates and Components for Claude Code: The Future of AI Coding Workflows
Claude Code is no longer just a coding assistant, it's becoming an operating system for software development. In this talk, I'll walk through how reusable templates, agents, hooks, skills, and MCP integrations can transform Claude Code into a structured, composable workflow engine. Drawing from building aitmpl.com and shipping these patterns in production at scale, I'll show how developers can stop prompting from scratch and start building on top of a shared, evolving component layer.
Auth Under Attack Catching JavaScript Auth Failures in Production Fast
Web Engineering Summit 2026Web Engineering Summit 2026
21 min
Auth Under Attack Catching JavaScript Auth Failures in Production Fast
Auth bugs rarely show up as “login is down.” They show up as redirect loops, stale sessions, broken refresh flows, and permission leaks after “small” changes. This talk walks through one real incident pattern and delivers a repeatable playbook for debugging fast and adding guardrails that keep auth stable in production.
HTML in Canvas: Bridging UI and GPU on the Web
Web Engineering Summit 2026Web Engineering Summit 2026
17 min
HTML in Canvas: Bridging UI and GPU on the Web
Santiago Colombatto
Tomas Ferreras
2 authors
Modern web development still relies on a strong separation between HTML/CSS for UI and Canvas/WebGL for rendering. In practice, combining both often leads to complex synchronization logic and a series of workarounds.In this talk, we’ll first walk through how these problems are typically solved today — including scroll synchronization, frame loop timing, scissor-based rendering, and mapping DOM elements into a WebGL scene — and why these approaches tend to be fragile and hard to scale.Using a set of experiments and websites developed at basement.studio, we’ll show these patterns in practice, combining real layouts with shaders and interactive effects.From there, we’ll introduce HTML-in-Canvas and show how it simplifies many of these problems — not as a finalized solution, but as a direction that removes the need for most of the synchronization and rendering workarounds we rely on today.We’ll also cover the challenges of building UI directly in WebGL, where layout, text, and interactivity become difficult to manage, especially in environments like WebXR.
Open Source Voice AI: How We Built ChatGPT's Voice Mode Infrastructure
Web Engineering Summit 2026Web Engineering Summit 2026
20 min
Open Source Voice AI: How We Built ChatGPT's Voice Mode Infrastructure
Ever wondered what it takes to power millions of voice conversations at ChatGPT's scale?When OpenAI needed infrastructure for ChatGPT's Advanced Voice Mode, they turned to LiveKit's open source infrastructure. Not a proprietary black box. Not a closed platform. Open source software that anyone can use, modify, and deploy.In this talk, I'll take you behind the scenes of building production voice AI infrastructure that handles millions of conversations:Why Open Source for Production AI – The technical and business reasons behind the choiceArchitecture Decisions – How we built for scale, reliability, and low latencyScaling to Millions of Calls – The challenges you don't anticipate until you hit themLessons Learned – What we'd do differently knowing what we know nowWhat's Possible Now – How you can use the same infrastructure for your projectsThis isn't a sales pitch, it's a technical deep dive with real production metrics, architectural diagrams, and honest discussions about trade-offs. You'll see the actual stack, understand the scaling challenges, and learn from our mistakes.Whether you're building your first voice agent or scaling to production, you'll walk away with insights from one of the largest voice AI deployments in the world. Because the infrastructure powering ChatGPT's voice mode is open source, and it's available to everyone.
MemLab: Automating Memory Leak Detection and Heap Analysis
Web Engineering Summit 2026Web Engineering Summit 2026
19 min
MemLab: Automating Memory Leak Detection and Heap Analysis
Memory leaks in single-page applications are often viewed as mere technical debt, but data shows they directly degrade user experience and engagement. In this talk, we introduce MemLab, an automated framework that identifies memory leaks by simulating user interactions and analyzing heap snapshots.
Scaling JavaScript Monorepos at Enterprise Level: Lessons From 200+ Packages
JSNation 2026JSNation 2026
22 min
Scaling JavaScript Monorepos at Enterprise Level: Lessons From 200+ Packages
Monorepo Metamorphosis: Reducing CI Load by Over 65% with Nx, pnpm & Predictive Build GraphsDoes your CI feel slower every time your monorepo grows? In this talk, I’ll share how we transformed a 200+ project JavaScript/TypeScript monorepo by applying predictive dependency graphs, Nx task-hashing, pnpm’s content-addressable workspace, and horizontally scaled runners to eliminate redundant work and shrink build+test cycles by more than 65%. If you’re looking to break the cycle of ever-increasing CI times and unlock real delivery velocity, this session provides a clear and practical blueprint.
Building ChatGPT and MCP Apps with All the Comfort of Modern TypeScript DevX
JSNation 2026JSNation 2026
21 min
Building ChatGPT and MCP Apps with All the Comfort of Modern TypeScript DevX
Billion of users are starting their searches on ChatGPT instead of Google.For JavaScript developers, this isn't just a trend, it's a new runtime: ChatGPT Apps. These new apps serves as a replacement for traditional web and mobile applications: interactive, tool-powered experiences living inside the world's fastest-growing AI platform. They benefit from packing an LLM right within the application.Giants have already shipped their own: Booking, Expedia, Accor, Figma, Uber... Now it's time to build yours!I built Skybridge, an open-source TypeScript framework for building them, and it comes packed with everything you'd expect from a modern JS dev environment. Come and learn how to build in this new ecosystem!
Using Spec-Driven Development for Production Workflows
JSNation 2026JSNation 2026
19 min
Using Spec-Driven Development for Production Workflows
AI coding assistants are great at completing small tasks or features. But what do you do when you're working with more complex codebases and need to build in-depth features that require upfront planningThis talk explores spec-driven development as a solution to this problem. I'll show you how modern AI coding assistants can help break down complex tasks into three distinct phases. We'll look at the real-world tradeoffs of this approach, and most importantly, how you can use it in your own projects right away.
Out-of-Order Streaming – The Future of Web Development
JSNation 2026JSNation 2026
26 min
Out-of-Order Streaming – The Future of Web Development
As the pendulum of web development swings back towards the server, streaming has become increasingly popular. Specifically, out-of-order streaming.Let's build our very own simplified version to explore how it works, what problems we are trying to solve, and what this future of web development looks like.
Click. Ship. Done. AI Agents on Cloudflare
JSNation 2026JSNation 2026
22 min
Click. Ship. Done. AI Agents on Cloudflare
AI agents are almost everywhere, but deploying one yourself still feels like it requires a PhD in infrastructure. What if it didn't? This talk breaks down what AI agents actually are, how they work, and why Cloudflare's platform makes it ridiculously easy to build and ship your own. Everything written with the language you love (or hate): JavaScript.We'll cover the agent loop, introduce MCP (Model Context Protocol) as the glue that connects agents to real world tools, and walk through Cloudflare's stack, from Durable Objects for stateful execution to Workers AI for inference.By the end, you'll deploy your own agent using a single command from a shared GitHub repo. No PhD required.
Building a JavaScript Engine in Rust: Lessons From Boa
JSNation 2026JSNation 2026
24 min
Building a JavaScript Engine in Rust: Lessons From Boa
JavaScript engines power the web, but what does it actually take to build one, and even contribute to the ones used by billions?In this talk, I'll share the journey of creating Boa, a JavaScript engine written in Rust, and what it taught me about how JavaScript really works under the hood. We'll explore how code is parsed and executed, and the surprising complexity hidden inside the ECMAScript specification.But building an engine wasn't just a technical challenge, it was also about building a community. I'll share lessons from leading an open-source project, growing contributors, and navigating the realities of maintaining a language runtime.Finally, we'll look at how this work extended beyond Boa, culminating in contributions to V8, the engine that powers Chrome, through the implementation of Temporal in Rust. This is the story of how an open-source project can evolve from experimentation to influencing the broader JavaScript ecosystem.
Orchestrating Content Workflows at Netflix Scale
Web Engineering Summit 2026Web Engineering Summit 2026
20 min
Orchestrating Content Workflows at Netflix Scale
Every title that reaches Netflix's millions of subscribers passes through a gauntlet of decisions — some made by rules, some by ML models, and some by human reviewers. And with Netflix's catalog growing faster than ever, getting all of them to work together reliably, at scale, is one of the hardest problems in production systems engineering.In this talk, we'll share how we rethought workflow orchestration from the ground up to build a framework where rule-based automation, ML models, and human-in-the-loop review aren't just bolted together — they're first-class citizens in the same pipeline. We'll get into the real challenges: routing decisions across heterogeneous components, isolating failures so a single bad signal doesn't cascade, and closing the feedback loop across the entire system. Along the way, we'll show why the architectural choices that make this work today are exactly what make AI agent integration tomorrow feel like a natural evolution — not a retrofit.If you've ever tried to build a production pipeline that doesn't fall apart when one piece changes — this one's for you.
AI Can Generate Tests for You, Now What?
Web Engineering Summit 2026Web Engineering Summit 2026
22 min
AI Can Generate Tests for You, Now What?
Tools like Playwright MCP (or AI) or Claude Code can generate tests for your code.Cursor can give you testing suggestions about your codebase that sounds logical within seconds also.Testing has never felt this easy before.Until the need for a full scale, seamless are effective testing strategy for your product arises.How do you know if these generated tests and suggestions really fit your standards and needs, despite looking so good?How do you, as the lead engineer, balance the generated tests across different testing quadrants, between the “what” and the “when” of a testing automation pillar and design a scalable architecture for your team, and beyond?How do you combine these AI tools to architect a scalable AI-driven testing workflow and still fully own your team’s code quality?Join my talk and let’s find out.
400 Tech Leads. Same Problems. None of Them Technical
Web Engineering Summit 2026Web Engineering Summit 2026
17 min
400 Tech Leads. Same Problems. None of Them Technical
After training and coaching more than 400 tech leads across companies and industries, one pattern keeps repeating: when tech leads struggle, it’s rarely a technical gap.In this talk, Anemari Fiser shares the most common challenges tech leads bring into coaching sessions - overload, unclear expectations, ownership confusion - and assumed alignment and why “getting better technically” almost never fixes them.Drawing from real coaching and training examples, the talk explores where tech leads get stuck, what they think the problem is, and the small but meaningful shifts that help them move forward.
From Vibe Coding to Vibe Engineering
React Summit 2026React Summit 2026
30 min
From Vibe Coding to Vibe Engineering
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.
Speed, Quality, and AI: You Can't Have It All (Or Can You?)
React Summit 2026React Summit 2026
28 min
Speed, Quality, and AI: You Can't Have It All (Or Can You?)
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.
Panel Discussion: Fullstack is Eating Frontend — Should FE Engineers Adapt?
React Summit 2026React Summit 2026
35 min
Panel Discussion: Fullstack is Eating Frontend — Should FE Engineers Adapt?
Kathryn Grayson Nanz
Kevin Ball
Scott Tolinski
Sam Selikoff
Alem Tuzlak
Ryan Skinner
6 authors
CLI, GUI, or Just Blind Trust? A Tour of Code Review Styles
React Summit 2026React Summit 2026
6 min
CLI, GUI, or Just Blind Trust? A Tour of Code Review Styles
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.
Taming the Flicker: Firebase Patterns for React Server Components
React Summit 2026React Summit 2026
7 min
Taming the Flicker: Firebase Patterns for React Server Components
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.
P2P React: Local-First State, Shared Truth
React Summit 2026React Summit 2026
27 min
P2P React: Local-First State, Shared Truth
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.
Framework Native Rendering Without Code Duplication?
React Summit 2026React Summit 2026
6 min
Framework Native Rendering Without Code Duplication?
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.
I Did Everything Wrong So You Don't Have To
React Summit 2026React Summit 2026
6 min
I Did Everything Wrong So You Don't Have To
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.
Ashes to Ashes, Spec to Spec: The Rebirth of Modern Testing
React Summit 2026React Summit 2026
29 min
Ashes to Ashes, Spec to Spec: The Rebirth of Modern Testing
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.
We Need More Than Prompts
React Summit 2026React Summit 2026
28 min
We Need More Than Prompts
Coding with an agent tends to settle into the same loop: prompt, check, re-prompt and repeat, burning time and tokens each pass. There's a better way, and it starts before any code gets written.

This talk puts two approaches head to head: the prompt-and-iterate loop most of us have fallen into, and spec-driven development. You'll see what each one produces, and what a spec gives you that prompting can't, including decisions you can review before any code exists and context your whole team can build on.
Building Bridges to a Post-SPA Future
React Summit 2026React Summit 2026
33 min
Building Bridges to a Post-SPA Future
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.
The UI That Builds Itself: Exploring the Generative Front-End
React Summit 2026React Summit 2026
28 min
The UI That Builds Itself: Exploring the Generative Front-End
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.
Designing for Failure: The Senior React Dev's Production Toolkit
React Summit 2026React Summit 2026
29 min
Designing for Failure: The Senior React Dev's Production Toolkit
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.
What the First Rule of ARIA Really Means
React Summit 2026React Summit 2026
28 min
What the First Rule of ARIA Really Means
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.
​How I use AI as a Technical Educator
React Summit 2026React Summit 2026
31 min
​How I use AI as a Technical Educator
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.
Building RSCs Framework on Rust: Architecture Decisions That Delivered 45x Performance
React Summit 2026React Summit 2026
29 min
Building RSCs Framework on Rust: Architecture Decisions That Delivered 45x Performance
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.

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.

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.

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.
Giving AI Agents Hands: Mobile Feedback Loops with Agent Device
React Summit 2026React Summit 2026
26 min
Giving AI Agents Hands: Mobile Feedback Loops with Agent Device
AI coding agents can generate React Native code quickly, but they still need a reliable way to see, touch, debug, and verify the app they are changing. This talk introduces Agent Device, Callstack’s agent-native automation layer for mobile apps, and shows how it gives coding agents a practical feedback loop on iOS, Android, TV, and desktop targets.

We’ll look at what that means in practice: how agents inspect the UI, interact with the app, collect evidence, profile React Native behavior, and turn exploratory work into replayable checks. Then we’ll show practical workflows for React Native teams: letting an agent implement and verify a feature, debugging a broken screen, turning exploratory QA into deterministic checks, and supporting AI-assisted migrations where implementation and testing feed into each other.

The goal is to show how agent-assisted coding changes when the agent can work against the real app, not just the source code.
A Guide to React Compiler Rendering
React Summit 2026React Summit 2026
32 min
A Guide to React Compiler Rendering
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.
Ripple: the Good Parts of React, Svelte, and Solid
React Summit 2026React Summit 2026
27 min
Ripple: the Good Parts of React, Svelte, and Solid
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.
Tanstack Start and How It Supports React Server Components
React Summit 2026React Summit 2026
27 min
Tanstack Start and How It Supports React Server Components
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.
The Evolution of App Development
React Summit 2026React Summit 2026
27 min
The Evolution of App Development
This Component Could Have Been A Class
React Summit 2026React Summit 2026
33 min
This Component Could Have Been A Class
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.
What RSCs Can Do in Next.js Today
React Summit 2026React Summit 2026
36 min
What RSCs Can Do in Next.js Today
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.
Agentic Interfaces: Tools, Skills, Generative UI and Web MCP
JSNation 2026JSNation 2026
31 min
Agentic Interfaces: Tools, Skills, Generative UI and Web MCP
Who is ordering Starbucks with ChatGPT? Will an Agent just make the perfect UI for you? Do we even need websites anymore? This app could have been an API!We like using AI, but we also like using websites! Do we add AI to our site, or does our site get added to AI? This talk looks at the current landscape of agentic interfaces and the future of UI, websites and browsers.
Training Engineers for AI Without Turning Them into Prompt Monkeys
TechLead Conf Amsterdam 2026: Adopting AI in Orgs EditionTechLead Conf Amsterdam 2026: Adopting AI in Orgs Edition
28 min
Training Engineers for AI Without Turning Them into Prompt Monkeys
AI is reshaping how engineers work, but many organizations are training teams in the wrong direction—optimizing for prompts instead of thinking. This leads to fast output, shallow understanding, and fragile systems. This talk focuses on how tech leaders and senior engineers can adopt AI while preserving engineering judgment, ownership, and long-term system quality. You’ll learn how to train engineers to use AI as a tool—not a crutch—without sacrificing craft or increasing complexity.
Taste in Software Development
JSNation 2026JSNation 2026
10 min
Taste in Software Development
Browser, API and Assistive Technology: A Love Triangle
JSNation 2026JSNation 2026
28 min
Browser, API and Assistive Technology: A Love Triangle
Accessibility can often be presented as a checklist but why do your accessibility tests with assistive technology not perform the way you intended? The hidden relationship between browsers, accessibility APIs and assistive technology may be the answer to your frustrations. Understanding this may be the necessary tool you need to smoothen your debugging process. 
Interviewing in the Post-LLM World
TechLead Conf Amsterdam 2026: Adopting AI in Orgs EditionTechLead Conf Amsterdam 2026: Adopting AI in Orgs Edition
29 min
Interviewing in the Post-LLM World
As LLMs become everyday tools for developers, the way we interview engineers must evolve.
We will learn strategies to adapt technical interviews, embracing AI as a tool while still assessing judgment, critical thinking, and collaboration.
Debugging Performance With AI
Web Engineering Summit 2026Web Engineering Summit 2026
6 min
Debugging Performance With AI
Profiling JavaScript is mostly easy. However, how do you profile gnarly performance issues? In this talk, you’ll learn a practical AI-assisted workflow for finding rendering bottlenecks fast. Using a real-world CSS performance bug, we’ll cover techniques like commit bisection, standalone reproductions, synthetic stress tests, and auto-generated lint rules to prevent regressions. We choose CSS because it is famously difficult to profile -- there are no stack traces, obvious breakpoints, or clear debugging workflows, which is why many rendering bugs go unfixed until users complain that the page feels slow. However, the same methodology can be used in dealing with other performance issues. You’ll also see how to use the Chrome DevTools MCP to give Claude direct access to a live browser session and accelerate investigation without replacing engineering judgment. The result is a repeatable process for going from “the page feels slow” to a pinpointed line of CSS in under an hour.
Rustifying Vite: Designing a Hybrid Toolchain for the Real World
Web Engineering Summit 2026Web Engineering Summit 2026
6 min
Rustifying Vite: Designing a Hybrid Toolchain for the Real World
JavaScript tooling is fast until it isn't. As projects scale, even well-designed JS-based tools start to hit ceilings around cold starts, dealing with large dependency graphs, and CPU-heavy transforms. The obvious answer seems to be "rewrite it in Rust" except that reality is messier.This talk is a deep dive into what actually happens when you introduce Rust into a JavaScript-first toolchain, with Vite as the core example. We'll explore how Vite’s architecture enables selective rustification, and what we learned from building hybrid pipelines that mix JavaScript and Rust without wrecking DX.
A Brief History of Code Review (And What's Next)
Web Engineering Summit 2026Web Engineering Summit 2026
8 min
A Brief History of Code Review (And What's Next)
Code review has come a long way. We’ve evolved from manual inspections and email patches to modern pull requests and automated testing. Yet, one big problem remains: developers are still stuck waiting on human approvals. Join me for a walk through the history of code review to see how our processes have adapted over the last 30 years. We'll examine the limits of our current workflows and explore how the new era of AI-assisted reviews is finally solving the code review bottleneck.
Friends Don’t Let Friends Agent Alone
TechLead Conf Amsterdam 2026: Adopting AI in Orgs EditionTechLead Conf Amsterdam 2026: Adopting AI in Orgs Edition
29 min
Friends Don’t Let Friends Agent Alone
This talk is about what gets unlocked when engineers pair with each other and an agent, instead of disappearing into silos with one human and one machine. We never paired to type. We paired to stay aligned, challenge assumptions, and make better decisions together. When code gets cheap to produce, the human collaboration layer matters more, not less. We'll explore what effective human+agent collaboration actually looks like in practice and you'll leave with a framework for keeping teams aligned without slowing them down. 

Chunking
JSNation 2026JSNation 2026
28 min
Chunking
We look into how bundlers place modules into output files in a process called "chunking".What are the competing metrics that can be influenced by chunking?Why is CSS and JS chunking completely different?What are performance considerations for large apps?How does JS chunking and CSS chunking work in Webpack/Turbopack/Next.js (on a high level)?
Agents on the Canvas With tldraw
JSNation 2026JSNation 2026
29 min
Agents on the Canvas With tldraw
At tldraw, we've been exploring the infinite canvas as a surface for real-time collaboration between multiple agents and multiple users. Learn about what works, what doesn't, and whether the future AI might live on the canvas.Our work with AI on the canvas began with makereal.tldraw.com, often cited as the first "vibe coding" tool to reach escape velocity in November 2023. We later did work with realtime drawing (drawfast.tldraw.com), autocomplete, and a canvas interface for AI with (teach.tldraw.com). In 2024, we shipped an AI workflows app (tldraw.computer) and then returned to our canvas AI learnings with a public starter kit for working on the canvas with cursor-style AI agents (https://tldraw.dev/starter-kits/agent) and then later our spatialized agents-on-the-canvas experiment (fairies.tldraw.com).
Beyond the Hype Cycle: Driving real ROI with AI in Your Organization
TechLead Conf Amsterdam 2026: Adopting AI in Orgs EditionTechLead Conf Amsterdam 2026: Adopting AI in Orgs Edition
27 min
Beyond the Hype Cycle: Driving real ROI with AI in Your Organization
88% of organizations now report using AI, yet only 39% capture meaningful enterprise value from it (McKinsey State of AI Survey, Nov 2025). The gap between "we use AI" and "AI transformed our business" has never been wider. In this talk, I'll dissect why most AI adoption metrics are vanity metrics dressed in executive clothing, drawing on strategic AI research and my own experience rolling out AI-powered tools across IKEA's global supply chain. You'll walk away with a practical framework for measuring what actually matters: workflow redesign depth, decision-quality uplift, and compounding capability gains, not chatbot logins per month or tokens burned by your teams.
Organic Leadership in the Age of AI: Why human Touch Becomes More Valuable Than Ever
TechLead Conf Amsterdam 2026: Adopting AI in Orgs EditionTechLead Conf Amsterdam 2026: Adopting AI in Orgs Edition
8 min
Organic Leadership in the Age of AI: Why human Touch Becomes More Valuable Than Ever
In this talk, Kseniia Korostelova shares the results of a real experiment where she attempted to delegate parts of her engineering leadership work to AI. From architecture decisions and feature planning to design reviews and performance feedback, some tasks worked surprisingly well while others failed completely.
These experiences led to the concept of Organic Leadership: a leadership approach that uses AI to remove noise while preserving the human judgment, trust, and context that teams rely on.
You will learn where AI can genuinely augment engineering leadership today, where it cannot, and why the rise of AI may actually increase the value of truly human leadership.
No Servers, No Cloud, No Masters: Make P2P Apps
Web Engineering Summit 2026Web Engineering Summit 2026
32 min
No Servers, No Cloud, No Masters: Make P2P Apps
Battle-tested applications with peer-to-peer OTA updates are running in production. Rapidly growing with millions of users added monthly.Using a module and a CLI tool, you too can deploy a peer-to-peer production application with drastically lower complexity than traditional deployment means.
Building for Agent Experience
TechLead Conf Amsterdam 2026: Adopting AI in Orgs EditionTechLead Conf Amsterdam 2026: Adopting AI in Orgs Edition
9 min
Building for Agent Experience
Every cloud platform was designed for developers: humans who read docs, click dashboards, and push to git. But AI agents are already using these platforms, and they experience them very differently. At Render, we've watched agents parse our marketing pages, struggle with our APIs, and surface (or not surface) our platform in LLM recommendations. Building our MCP server, CLI, and agent skills meant designing for two users at once, and rethinking what "developer experience" even means when the developer isn't human. This talk distills what we learned: where our assumptions failed, what we changed in response, and the concrete principles engineering leaders can apply to build tools, docs, and APIs that serve both humans and AI agents.
Ensuring Quality with AI
TechLead Conf Amsterdam 2026: Adopting AI in Orgs EditionTechLead Conf Amsterdam 2026: Adopting AI in Orgs Edition
7 min
Ensuring Quality with AI
While most of the conversation around AI in software engineering is about using it to pump out new features at a rate we haven't seen before, one of the most interesting use cases for AI is ensuring the quality of your product. From PR reviews to bug fixes to code cleanup, AI can help engineering teams focus on what they enjoy working on, while helping them create a better product. 
Stress Test Your Reflexes (And My App)
Web Engineering Summit 2026Web Engineering Summit 2026
32 min
Stress Test Your Reflexes (And My App)
What happens when you turn your audience into a live, distributed load test?We will kick off this session with a high-stakes, multiplayer "Whack-a-Mole" challenge played right from your phone. As you compete for the leaderboard, a live stream of concurrent data will be generated to showcase realtime web capabilities in action across devices.After playing around, it is time to get serious by digging into the challenges, architecture and technologies used when building such a platform. Discover how helpful or distracting AI can be during this process.Key takeaways include:AI: The Good & The Glitchy!The Stack: NextJS, Supabase.Realtime: No longer refreshing the page.Leave the theory behind and see how modern tools and a bit of trial and error handle the chaos of live user interaction.
Scaling AI Adoption: The Real Challenges of Transforming 300 Engineers
TechLead Conf Amsterdam 2026: Adopting AI in Orgs EditionTechLead Conf Amsterdam 2026: Adopting AI in Orgs Edition
30 min
Scaling AI Adoption: The Real Challenges of Transforming 300 Engineers
Most companies talk about becoming "AI-native". Very few actually do it.

In this talk, I’ll share how we’re approaching the upskilling of ~300 engineers to move beyond experimentation and into real, repeatable AI-native development.

We’ll cover how we’re introducing new paradigms like AI-Native Engineering (AINE) and Spec-Driven Development, how we’re structuring the individual contributor journey, and how we’re driving adoption across teams with very different levels of maturity.

More importantly, we’ll dive into what doesn’t work: resistance patterns, false starts, over-reliance on tools, and the gap between perceived and actual productivity gains.

This talk will give you a concrete blueprint along with the trade-offs and lessons learned along the way.
Dead Code Shouldn’t Exist: How We Removed 28k Lines of Code, One Knip at a Time
Web Engineering Summit 2026Web Engineering Summit 2026
35 min
Dead Code Shouldn’t Exist: How We Removed 28k Lines of Code, One Knip at a Time
Ever wonder how much of your codebase is just… hanging around, doing nothing? At Sentry, we did too - and the answer was more than we expected. In this talk, I’ll share how we used Knip, a powerful tool for detecting unused files, exports, and dependencies, to declutter our frontend codebase. You’ll learn about the practical steps we took to safely identify and remove dead code, how we integrated Knip into our workflows, about unexpected edge-cases and what we learned along the way. Whether you're maintaining a massive monolith or just looking to tidy up, this session will give you practical strategies - and maybe a little inspiration - to start decluttering your own codebase, one Knip at a time.
Stress Test Your Reflexes (And My App)
JSNation 2026JSNation 2026
32 min
Stress Test Your Reflexes (And My App)
What happens when you turn your audience into a live, distributed load test?We will kick off this session with a high-stakes, multiplayer "Whack-a-Mole" challenge played right from your phone. As you compete for the leaderboard, a live stream of concurrent data will be generated to showcase realtime web capabilities in action across devices.After playing around, it is time to get serious by digging into the challenges, architecture and technologies used when building such a platform. Discover how helpful or distracting AI can be during this process.Key takeaways include:AI: The Good & The Glitchy!The Stack: NextJS, Supabase.Realtime: No longer refreshing the page.Leave the theory behind and see how modern tools and a bit of trial and error handle the chaos of live user interaction.
FullStack Monitoring with Open Telemetry: End-to-End Observability for Modern Applications
Web Engineering Summit 2026Web Engineering Summit 2026
30 min
FullStack Monitoring with Open Telemetry: End-to-End Observability for Modern Applications
In this talk, I’ll show how to instrument applications end-to-end with OpenTelemetry, capturing metrics, traces, and logs across the entire request lifecycle. You’ll learn to pinpoint errors, understand why they happen, and fix them faster – guided by real-world examples and a starter template for quick adoption.You’ll also see how to turn telemetry into automated insights using MCPs (Model Context Protocol) to generate reports from your observability stack. Using a Grafana MCP to produce incident summaries, release health reports, and diagnostics with open-source tooling.
Your Platforms Matter More Than Ever With AI
TechLead Conf Amsterdam 2026: Adopting AI in Orgs EditionTechLead Conf Amsterdam 2026: Adopting AI in Orgs Edition
29 min
Your Platforms Matter More Than Ever With AI
Manual coding as the primary activity in software development is ending.

Developers will not spend most of their time writing code. They will review, steer and constrain what AI systems produce. The bottleneck shifts from typing syntax to defining context, boundaries and intent.

When code can be generated instantly, the leverage moves to the system around it. Your internal developer platform, your golden paths, your compliance controls, your deployment standards and your observability become the real foundation of product development.

Without a strong platform, AI accelerates fragmentation. Different tools, inconsistent environments and ad hoc processes will compound into chaos at machine speed. With standardized workflows and paved roads, AI becomes a multiplier for quality and consistency instead of risk.

At the same time, each developer will likely be responsible for more software than ever before. As output increases, cognitive load must decrease. That means less variability, fewer bespoke setups and stronger defaults. The complexity of the systems must go down even if the volume of code goes up.

Internal developer platforms are no longer a productivity initiative. They are a prerequisite for succeeding in the AI era of software development. If you are rethinking your Content experience platform for this AI-driven era, partnering with an engineering-led headless CMS agency like FocusReactive turn these principles into a practical, scalable content platform.
How We Used AI to Build TanStack AI
Web Engineering Summit 2026Web Engineering Summit 2026
33 min
How We Used AI to Build TanStack AI
TanStack AI is an open-source project built to make it easy for developers to use AI in their applications and in this talk Alem will explain how they used AI to help them prototype concepts, solidify API's and ship the final library in under a month's time. Learn practical use-cases for AI in your day to day life through the lessons learned on the development of TanStack AI.
Panel Discussion: Redefining Engineering Careers in the AI Era
TechLead Conf Amsterdam 2026: Adopting AI in Orgs EditionTechLead Conf Amsterdam 2026: Adopting AI in Orgs Edition
30 min
Panel Discussion: Redefining Engineering Careers in the AI Era
Kevin Ball
 Lindsey Simon
Gregor Ojstersek
Fabrice Bernhard
Nihan Bircan
5 authors
Autonomous AI Agents in Action With the Ralph Wiggum Method
Web Engineering Summit 2026Web Engineering Summit 2026
28 min
Autonomous AI Agents in Action With the Ralph Wiggum Method
The hype around AI coding agents is very real, and autonomous coding systems are improving fast. In this talk, we'll explore the "Ralph Wiggum" method, where AI agents run in persistent iteration cycles until tasks are actually complete. You will learn about backpressure mechanisms to let the LLM self-correct and retry without human intervention. We will discuss how to structure the prompts, practical patterns for turning test failures into actionable AI feedback, and honest insights about when this approach works best versus where it falls flat. This is about making AI agents actually useful for real work by applying agentic engineering principles, not vibe coding. If you're curious about the future of AI-assisted development and want to see what's possible when we design systems that expect and handle failure, this talk is for you.
Life of an ESM in Node.js – and How It's Changing for the Better
JSNation 2026JSNation 2026
29 min
Life of an ESM in Node.js – and How It's Changing for the Better
The JavaScript ecosystem is moving towards a standardized module system, and Node.js is evolving to aid its adoption. What actually happens when Node.js loads an ES module today? This talk walks the full pipeline - resolution, loading, parsing, compilation, linking, instantiation, and evaluation. We will cover how the work is split between V8 and Node.js, where Node.js differs from browsers and bundlers, and the recent changes in Node.js that unlocks new patterns for better interop, performance, and customization in ESM. You will leave with a clearer mental model of how ESM is loaded in Node.js, shed obsolete knowledge and misconceptions, understand where to look when your modules don't work, and learn about the new capabilities that will help you write, run, and share ESM code better on Node.js today.
How I Taught LLMs How to Svelte
Web Engineering Summit 2026Web Engineering Summit 2026
33 min
How I Taught LLMs How to Svelte
It's undeniable that LLMs are slowly (and not even that much) but steadily changing the way we write code. But they have a problem: once you start using something outside of their training set, the performance quickly degrades.Releasing Svelte 5 (with a pretty big syntax rewrite) right before those LLMs started to get good at code was unfortunate, but luckily, there's a way around this! MCP servers can add context for the LLM and guide our future overlords on how to write perfect Svelte code. Learn how we've built the official Svelte MCP and which techniques we used to make LLMs master Svelte 5's runes and reactivity!
The Monorepo Multiplier: 10x Your Team with Better Architecture
TechLead Conf Amsterdam 2026: Adopting AI in Orgs EditionTechLead Conf Amsterdam 2026: Adopting AI in Orgs Edition
28 min
The Monorepo Multiplier: 10x Your Team with Better Architecture
In this talk, we'll explore the compounding benefits of monorepo architectures through two lenses: Developer Experience (DX) and the emerging concept of Agentic Experience (AX).The Polyrepo Problem
- Context switching tax
- Dependency version hell
- Inconsistent tooling
- Why AI agents fail in fragmented codebases

The Monorepo Solution
- Unified context for humans and AI
- Atomic changes across boundaries
- Consistent patterns and practices
- How AI tools become 10x more accurate
Limited to 100 talks. Adjust filters for additional content.