Name: JSNation US 2026
Start: 2026-11-16T13:00:00.000Z
End: 2026-11-19T22:59:00.000Z

Taz Singh

Lera

Violina Popova

Seungho Park

Vishnudhasan Govindarajan

Daria Shabala

Shifra Williams

HT Sahin

David Pugh

Amanda Witecki

Houda Mouttalib

Dennis Schneider

Sulagna Ghosh

Anton Zalaldinov

João Cidade Silva

David Passarelli

Ryan Ogden

Boris Karaivanov

Sauparna Sarkar

Arash Sarfehjou

khouchane Mahmoud

Vitor Barbosa

Daniel Hrynusiw

quinton sheppard

Basseydou OUATTARA

Fathima Fasna

Corbett Weinberg

Julián Parrilla Calvo

Mathew Langenberger

Srikanth Doddi

eran

Amy Rae Som

Yakovlev Eugen

Ellis Antaya

You were wrong about MCP being dead, and you probably ignored WebMCP. Now it's time to skill up.Agents are increasingly part of every workflow we do, but many websites and app haven't adapted yet. first-party integrations ship without a UI. Screen scraping is expensive. Computer use is too slow and brittle to get real work done. We want your app in our agents. WebMCP is a new browser spec that lets websites and apps expose their features as structured, callable tools. Run it inside the user's tab, so it uses the browser's existing auth and security model.In this talk, Wes will show how WebMCP enables co-browsing, natural-language input and batch processing. We're human, we still want to use websites and apps.  We just want to use them with our agents too!

WebMCP: Clicks n' Clankers

Wes Bos

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

AI-Native Product Engineering

Kent C. Dodds

A few years ago, Ryan Carniato described frontend's existential crisis: users expect more interactivity, and the JavaScript to deliver it costs more than our pages can afford. Escaping that trade-off needed clever solutions, and none of the contenders did so without giving something up. Ryan now thinks the trade-off was unnecessary. This talk puts today's frameworks, from HTMX to React, on one grid. He walks this grid with Solid 2.0, starting at zero JavaScript and ending at a fully optimistic live client, all in the same framework.

Frontend's Existential Crisis, Revisited

Ryan Carniato

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

Build a Production Agent Harness

Tejas Kumar

Agentic Kernel Optimization at the Scale of the Web

 Joshua Lochner

JavaScript has been around for almost 30 years and we are still finding ways to hurt ourselves with it.Sit back, relax, and join me on this journey through the history of JS security vulnerabilities. We will be starting in the days of innerHTML abuse and Cross-Site Request Forgery, moving along through the JSON hijacking era, making a stop to take a look at npm supply chain abuse, and landing in what we’re all dealing with presently: how AI assisted coding is introducing new vulnerabilities in ways we have not had to deal with before. By the end, you’ll have a better understanding of how JS’s attack surface has evolved, why bugs keep resurfacing under new names (cough cough, it’s trust), and what patterns to watch out for with current code you’re shipping. You’ll also understand why XSS has always been a top OWASP injection vulnerability, and will continue to be until we enforce better security practices.You don't need a security background to follow along, you just need to have run npm install and trusted what came back.

Everything is Fine: A Brief History of JavaScript Security

Rachel White

Learn how 3 creative award winning projects work, who and why they make them, and how you can get started as well.The three websites could be <a href="https://www.shopify.com/editions/spring2026" target="_blank">Shopify's editions</a>, and two other award winning websites made by agencies or by me.

Making 3D Websites Looks for Fun and for Profit With React Three Fiber

Daniel Velasquez 

Today, every website downloads and stores its own copy of large files like AI models, WebAssembly modules, Web fonts, and popular JavaScript libraries. If two websites use the same file, the browser downloads it twice. In this talk, I present the Cross-Origin Storage (COS) API — a proposed shared cache where files are identified by their SHA-256 hash, not by URL. I show both the imperative JavaScript API and the declarative forms via import attributes, HTML, and CSS, with live demos. After this talk, attendees will know how to use COS in their own projects to avoid redundant downloads and reduce storage use across the web.

Cross-Origin Storage: A Shared Cache for the Web

Thomas Steiner

JavaScript Framework authors face a brutal tradeoff when it comes to observability, either ship "blind" code and rely on 3rd parties to brittlely monkey-patch your API, or bloat your bundle with heavy observability dependencies. Both options hurt developer experience and performance.Tracing Channels changed this. A native, zero-dependency pattern that allows frameworks to emit events that are contextualized, and execution-correlated end to end.In this session, I'll show how tracing channels enable open observability APIs that progressively enhance with newer Node.js versions and gracefully degrade with zero overhead. We will also take a look at how popular libraries and frameworks that we use today implement their tracing channels and the patterns that allows them to benefit users and APM providers.Stop paying the instrumentation tax. Learn how to build observable frameworks by default, giving your users control without the cost.

Instrumentation Without the Tax: Native Tracing Channels in Node.js

Abdelrahman Awad

For years, frontend engineering has focused on building interfaces for people to interact with applications through screens. We learned to design for different interaction models, from mouse and keyboard to screen readers and voice control.Now with AI agents comes another interaction model. Instead of navigating buttons and forms, they can increasingly interact with applications through structured capabilities such as WebMCP and other agent interfaces. This raises a new question: what does good frontend design look like when not every interaction goes through the UI?In this session, we'll explore how accessibility principles provide a useful foundation for thinking about agent experiences, and why frontend engineering is becoming more important rather than less. Through practical demos and experiments, we'll compare human, assistive technology, and agent interactions with the same application, and discuss what this means for interface design, UX validation, testing, and the future of frontend development.

Frontend Beyond the Screen: Where AI Agent Is A User

Maya Shavin

A more and more common story: You're asked to add AI to a product. Not a chatbot. Not an AI platform. Just one small feature that needed to be smarter. In this talk I'll share practical lessons from shipping a small LLM feature in production: how to keep the architecture simple, how to set guardrails, how to ethically communicate with your values, and how to decide when AI is actually the right tool. This isn't the first time a big technology hype catches up to us and might creep us out at first, and this talk will look at this history, too.

The Feature That Didn't Need To Be Smart

Carmen Huidobro

I ran all 324 historical and active ECMAScript proposals through TypeSafe AI's System One model (Jev) and Jev-like models to classify where each idea came from and score it on domain shape, adoption path, cognitive load, web-compatibility risk, and runtime changes.In this talk, we look at thirty years of language design through that dataset to uncover where JavaScript features actually originate, the seven buckets every proposal falls into, and the surprising patterns that decide whether an idea becomes new syntax or a standard library API. You will walk away with a clear mental model of how language ideas are born in TC39, alongside a live explorer to query any JavaScript proposal yourself.

TC39 Delegate and AI Labs

Hemanth HM

In this talk, we’ll explore how to build multimodal AI agents that understand voice, interpret images, hold short-term memory, and respond intelligently - all running entirely in the browser. No server, no cloud APIs, and no installation. Using modern tools like WebGPU and WebAssembly, we’ll see how far the open web has come in enabling real-time, privacy-preserving AI experiences.

Look Ma, No Hands! Multimodal AI-Agents in the Browser

Nico Martin

I have been running an AI second brain as a developer for the past year, and it saves me at least 20 hours every week. It knows my repos and the conventions in each one, dispatches coding work to run in the background, drafts my email replies, and pings me on Slack when something needs my attention. In this talk I will show you how to build one in TypeScript. We will walk through the four parts that make it work. The memory is just markdown files that the agent writes to and curates itself. Hybrid search runs over that memory so the agent pulls the right context at the right time. A scheduled loop makes it proactive, reviewing what happened yesterday, promoting what mattered into long term memory, and surfacing what needs me today. And an integration layer connects all of it to my repositories, my inbox, and the rest of the platforms I actually work in. You will leave with the full architecture and a clear path to building your own.

Build Your AI Second Brain in TypeScript

Cole Medin

Browsers can also run Node.js. Sort of. With enough lies in the right places. This talk is about building an almost fully compatible Node.js runtime that lives entirely inside the browser, no server, no containers, no remote sandbox.  Once you have a runtime, you can give it to an agent. The agent writes code, runs it, reads the output, tries again. All of it in the tab.  We'll cover what's faked, what breaks, and what works better than expected.

Look, I Have a Runtime in My Browser

Theodore Vorillas

In this talk we'll dive into the intricate parts of re-architecting and building Harper Fabric's database management system UI along with building the UI for our orchestration layer from scratch. Highlighting how we made sure we built the application to scale with smooth authentication. Looking into how we handled routing for this one app being deployed into environments with different scopes of use, how we kept a react client-side app in sync with server-side actions, and scaled user authentication and permissions for distributed clusters with multiple nodes.

Re-architecting a DBMS UI From Scratch

Austin Akers

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

Ship a Next.js App with Claude Code

Maurice de Beijer

Every JS developer uses Copilot or Cursor. Few have built the tools these assistants invoke. MCP... the protocol behind AI tool integrations...is pure TypeScript: Zod schemas, async functions, Bun runtime. This talk shows how your existing skills unlock a new category of developer tooling.

Building AI-Powered Dev Tools With Just TypeScript

Faizan Akhtar 

AI has made code generation nearly free, but reliable systems still require architectural intent. While the world is moving toward having many agents orchestrate and manage your code, this approach can also lead to brittle orchestration and unverified execution. So in this talk, we'll focus on the right primitives you can use to turn rapid prototypes into coherent production systems. Learn how to design agent infrastructure that offers high observability and scales effectively.

Slopbowli-fication of Software

Aayush Kapoor

Ready to go from a plain repo to a workflow that changes code, verifies it, and merges it — on its own?AI coding demos look magical, but most stop at the pull request — and leave you wondering how to actually trust one at scale. The moment you point an agent at real repos, the questions pile up: how do you know it didn't break something? What stops a retry loop from running forever? When do you pull in a human? And who actually clicks merge? This workshop is the part the demos skip. You'll take a real repo and build the missing machinery: verification first, then an agent that does the work, proves it, and closes the loop by merging the safe changes itself.The core lesson: an agent can only automate what it can verify — and the loop isn't real until it merges.What you'll build:<ul><li>A repo made agent-ready — real tests, CI, and a baseline check</li><li>Your own skill, from scratch, that makes a code change and proves it didn't break anything</li><li>A verification gate that lets the agent fix only what its change broke — no false positives</li><li>A bounded execution loop that retries, then hands off to a human instead of hiding failures</li><li>An auto-merge step that closes the loop — merging the change on green, with no human in the seat</li></ul>Topics covered:<ul><li>Splitting a task into a deterministic lane (scripts, zero model cost) and a non-deterministic lane (real judgment)</li><li>Writing tests and wiring CI so the agent has eyesight into the repo</li><li>Capturing a baseline and chasing only the NEW failures your change introduced</li><li>Authoring an agentic skill from scratch: what it reads, what it does, what it writes back</li><li>Putting the loop on a leash — bounded retries, stable-green checks, routing failures to a human</li><li>Closing the loop with auto-merge — gate on green, merge the safe changes, escalate the rest</li><li>Designing the skill so it composes into a larger fleet later — one reliable unit first, scale second</li></ul>This isn't a demo — it's a build. You'll write TypeScript, add real tests, and wire up a workflow that runs end to end: change, verify, and merge, on its own. By the end you'll have a working skill and the confidence to point it at your own codebase on Monday morning.

Creating Autonomous Verifiable Agentic Workflows With Human in the Loop

Konstantinos Leimonis

Advanced unit testing for web accessibility empowers developers to build inclusive digital experiences from the ground up. By integrating accessibility testing into unit testing workflows, developers can identify and address accessibility issues early, fostering a more accessible web for all users.

Advanced Unit Testing For Web Accessibility

Raihan Nismara

In this talk, we’ll explore how to evolve beyond primary-500 and dark: classes toward semantic, variable-driven design systems that unify your entire app - from components to layout to AI-generated UI.

Design Systems for Humans and Machines

Kiril Peyanski

AI-generated code speeds up development—but it also accelerates security mistakes. When developers trust generated output without proper review, vulnerabilities slip into production silently. This talk explores real security pitfalls introduced by AI-assisted coding, explains why traditional review habits break down, and shows how attackers exploit these blind spots. You’ll learn how to use AI productively without surrendering security responsibility.

Security Pitfalls in AI-Generated Code: What Happens When Developers Skip Review

Kristiyan Velkov

Telling your AI coding agent "please don't commit directly to main" is about as effective as asking your cat not to knock things off the table. LLMs are non-deterministic by nature - a polite prompt instruction is not a security boundary. In this session, you'll learn how to enforce what you can't simply ask for. We'll dive into lifecycle hooks that intercept tool calls before they execute, blocking unauthorized Git commits, file deletions, or rogue shell commands at the architectural level. We'll also explore how to run coding agents autonomously and safely inside sandboxes - so your agent can do real work without being a liability. Whether you're building agentic workflows or just trying to stop your AI colleague from pushing directly to production: this talk gives you the controls that prompts never will.

"Please Don't Delete My Repo": Why You Can't Trust Your AI Coding Agent (And What to Do About It)

Daniel Sogl

What happens when AI tools meet the realities of a 130-year-old organisation with legacy systems, complex processes, and high expectations for reliability? In this talk, I’ll share practical lessons from introducing AI-assisted software development in a traditional environment: where it genuinely accelerates delivery, where it fails, and how teams can use it responsibly. Expect real examples, workflows, and honest insights on using AI beyond the hype.

Using AI to Write Software at a 130-Year-Old Organisation

Rumen Manev

<pre>Table of contents:</pre><ul><li><pre>Caching at Scale: The Freshness vs. Performance Trade-off</pre></li><li><pre>The Problem: Fresh Data Is Expensive</pre></li><li><pre>Our Architecture: From Browser to Database</pre></li><li><pre>What Happens When Traffic Scales?</pre></li><li><pre>Finding the Real Bottlenecks</pre></li><li><pre>The Three Constraints: Freshness, Cost, and Resilience</pre></li><li><pre>Why SSR Changes the Equation</pre></li><li><pre>The Solution: Cache at Every Layer</pre></li><li><pre>Redis: Taking the Pressure Off SSR</pre></li><li><pre>Pre-render What Doesn't Need to Be Rendered</pre></li><li><pre>Different Data, Different TTLs</pre></li><li><pre>Making Kubernetes Absorb the Spikes</pre></li><li><pre>Fine-Tuning: Finding the Right Cache Boundaries</pre></li><li><pre>What We Learned in Production</pre></li><li><pre>The Takeaway: Caching Is an Architectural Discipline</pre></li></ul>

Many Layers of Cache: How We Serve Millions of Pageviews With Node.js, Redis, and a Six-Pod K8s

Chris Gabardo

AI systems have a new class of vulnerabilities that most developers aren't thinking about yet. This talk covers how they work, what's been exploited in the wild, and where the field is headed.

The Vulnerabilities Hiding in Your AI Workflow

Aviv Keller

Every SSR setup, Next.js, Nuxt, SvelteKit, doesn't matter, has a brief window where server output and client output are allowed to disagree, and a bug that lives exactly in that window will lie to you: it looks like CSS, it looks like a race condition, it looks random. I hit one in Meshery, a CNCF Kubernetes platform, chasing a broken logo animation that turned out to be a rendering-boundary mismatch introduced by a 2022 commit, invisible until I traced it through git history. This isn't a Next.js talk, it's about a debugging instinct that transfers across any framework's SSR boundary: how to recognize when "flaky" actually means "boundary problem," how to trace a regression in a codebase you don't own, and what changes in how you review PRs once you've been burned by this once.

The Bug That Wasn't a Bug: Debugging Across a Rendering Boundary You Don't Control

AI agents have gotten remarkably good at thinking and remarkably bad at showing. Most agentic products still respond with paragraphs and markdown tables. This talk covers generative UI, letting the agent produce the interface best suited to the moment. We'll look at the emerging protocol layer, including Google's A2 UI, and walk through a working example. You'll leave knowing where generative UI fits in your stack and how to ship a first version without rewriting your front end.

Your Agent Is Brilliant, Your UI Is Static

Michael Madsen

QUIC in Node.js has been a work in progress for a long time and we're very nearly there. If you want to know how to use it, you can refer to the docs. If you want to know some of the gnarly details of what's happening under the API, this is the talk. We're going to go deep.

QUIC in Node.js ... The Gritty Details

James Snell

Python's scientific and data ecosystem rests on one library: NumPy. Pandas, scikit-learn, SciPy, and most ML tooling are built on top of it. JavaScript has never had a real equivalent, and that gap is a big reason serious numeric and data work still defaults to Python. The hard part about bringing NumPy to JS? Performance.numpy-ts is a complete NumPy for TypeScript and JavaScript, and this talk is the story of making it fast. The first version was 15x slower than native NumPy. The obvious move, rewriting hot paths in WASM, got it to roughly 2x slower and then stalled, for reasons that turned out to have nothing to do with FFI overhead. The fix was architectural: changing where the array data lives.We'll trace that journey across 7,159 benchmarks, from 15x slower to faster than native, and the copy tax hiding inside most WASM-accelerated JS libraries along the way.

Who Owns the Bytes? Making numpy-ts as Fast as Native

Nicolas Dupont

State management has traditionally focused on synchronizing UI interactions, frontend stores, and backend persistence. But AI agents introduce a new type of actor into modern applications: autonomous workflows that can read, execute, and modify application state alongside human users. In this session, we explore how frontend state management concepts can evolve into shared full-stack architectures where both humans and AI agents collaborate on the same data model. Using Angular-based application examples, we will examine sandboxed agent execution with forked state snapshots, deterministic merge strategies, concurrent updates between users and agents, and observable agent actions. Rather than treating AI as an external API call, this talk presents agents as first-class participants in application state transitions. We will extend familiar concepts such as stores, signals, reducers, and event streams beyond the frontend into backend orchestration systems that keep human and agent state consistent. Attendees will leave with practical architectural patterns for building collaborative human + AI applications using ideas FE developers already know.

Human + AI Shared State Management: Extending Frontend Patterns into Agentic Systems

Austin Zhang

Lo, at stage two and point-seven of the ECMAScript standard proposal process, there stands a gate to a dark reflection of our own realm — a realm the light can never touch, where only the fleeting shadows of our banished code can dwell. Fear not, traveler: at such time as the ShadowRealm is loosed upon the web platform, this talk will see that you stand at the ready to command its dark and fearsome majjycks!Okay, okay — but with a name like "ShadowRealm," how could I resist? This proposal would introduce a new kind of realm specifically designed for isolation, allowing us to offload code to a "clean room" realm with its own global and built-in objects but _not_ its own execution context. The proposed syntax is exceptionally simple and the theoretical use cases are solid, but how useful would a ShadowRealm be in practical terms? What problems would it solve; what problems would it _fail_ to solve? Will I be able to resist showing up for this talk in a wizard costume (I will absolutely be able to resist this, yes)? In this talk we'll take a guided tour of the ShadowRealm proposal, no runes or portals required.

Banishing JavaScript to the ShadowRealm

 Mat Marquis

A few lines of code and UI theme will follow any color that you want. Do you want it? Explore the OKLCH color space for creating dynamic themes! This color model ensures better a11y, predictable color transformations and supports the wide-gamut P3 colors. When it comes to changing colors by code, RGB, HSL, or LCH can lead to low contrast and poor accessibility; but OKLCH is specifically designed to avoid unexpected results with color transformations. This talk will guide you on implementing dynamic themes using OKLCH in your JS project along with Tailwind CSS, helping you automatically generate accessible palettes with vibrant, accurate colors.

Automatic and Accessible Dynamic Themes With OKLCH Color Space

Nina Torgunakova

Today’s generation of web AI is largely confined to server roundtrips: users type into a prompt box, wait seconds for a cloud API response, and pay per-token fees while streaming sensitive private data to remote servers.But the next frontier of web development is rich, sensory, and on-device. Modern web applications can now perceive the user’s physical environment through the camera and microphone, process visual and spatial feeds at 60 frames per second, and fuse that perception with on-device language reasoning—all executing locally on the client's GPU with zero cloud infrastructure.In this fast-paced 20-minute talk, we showcase what the future of web applications looks like with High-Performance, Multimodal Web AI, powered by Google's LiteRT (@litertjs/core and @litert-lm/core):<ul><li>Perception at 60 FPS: How WebGPU compute pipelines allow web apps to run real-time monocular depth estimation, multi-class segmentation, and 4x neural super-resolution directly on live video and canvas feeds.</li><li>On-Device Cognitive Reasoning: How running local language models (like Gemma 4) in browser VRAM enables instant comprehension, summarization, and conversation without network latency.</li><li>The Multimodal Fusion Loop: How perception models pass structured visual and spatial features directly to on-device reasoning models, enabling web apps to understand what users see and point at in real time.</li><li>Actionable In-Browser Agents: How local models can invoke JavaScript functions and browser APIs to manipulate the DOM, edit media, or interact with local storage automatically.</li></ul>Through live interactive demonstrations—including real-time spatial vision copilots and in-browser media editing studios—attendees will discover how to transition from building passive web pages to creating responsive, intelligent multimodal web experiences.

Taming the Web AI Beast With Google`s LiteRT.js: Seeing, Hearing, and Thinking in JavaScript

Ping Yu

AI coding assistants are shipping code to production faster than our monitoring and testing strategies can keep up. This talk explores the hidden reliability risks of AI-generated code like unpredictable error patterns, missing instrumentation, and test suites that miss what matters. This session offers a practical framework for adapting your observability stack to a world where you didn't write half the codebase.

When AI Writes Your Code, Who Monitors It?

Abeetha Bala

Abhishek Gawande

Software engineers know that every system carries the weight of past decisions. The human mind is no different. We all run beliefs, habits, and reactions that were written years ago, often for problems that no longer exist. This talk explores how concepts like technical debt, legacy systems, and refactoring can help us better understand ourselves, make better decisions, and break free from outdated mental patterns.

Your Brain Runs On Legacy Code

Kate Astrid

WebLLM brings local AI inference to the browser using WebGPU, WebAssembly, MLC-LLM, and Apache TVM. As WebLLM has grown to support more capable models and applications, many of the important problems now sit at the boundaries around model execution: loading large artifacts efficiently; coordinating work across JavaScript, WebAssembly, and WebGPU; supporting different model architectures and device capabilities; connecting model outputs to application logic; and preserving state within an ephemeral browser environment. This talk will cover recent work in WebLLM across these boundaries. We will cover cross-layer profiling and runtime optimizations that go beyond model kernels to reduce memory use, synchronization, and token-generation overhead across the full execution path. We will also discuss explicit compiler-runtime interfaces and model manifests, which define how compiled models expose their capabilities and requirements and enable a common path for multimodal and hybrid models. At the application boundary, WebLLM integrates XGrammar and structural tags to constrain generated outputs into structured data and tool calls. Finally, because a page reload or worker termination can otherwise discard an ongoing generation, WebLLM extends browser-local persistence from cached model artifacts to active inference, using OPFS-backed token journals and asynchronous KV-cache checkpoints to restore and continue interrupted generation.

WebLLM 2.0: Engineering Browser AI Across Execution, Interface, and Storage Boundaries

Akaash Parthasarathy

AI is writing a growing share of my production code, and it fails in ways my old testing habits were never built to catch. This is the honest field report: what breaks, what I test for now, and the checks that actually catch it before it ships.

What I Actually Test Before AI-Written Code Ships to Production

Artemis Leonardou

A signal is just a function that writes down who called it. In 20 minutes, we build that idea from nothing into a working reactive system — then show how it became four npm packages that run unmodified React components without a virtual DOM, no re-renders, no reconciler, backed by 123 passing tests.

Signals From Scratch: Building a React Replacement in 20 Minutes

Saman Abbasi

When an enterprise JavaScript monorepo or merge queue experiences flaky test runs or deployment pipeline failures, developers lose hours debugging large logs across multi-package builds. I will give the audience a practical blueprint for an edge-triggered AI incident responder that acts as an ephemeral agent inside a self-hosted CI job. You will learn how my team built a stateless system using Claude Code that automatically spins up when merge train health thresholds dip, conducting "differential diagnosis" against historical test logs to catch elusive semantic conflicts that local passing branches missed. We’ll cover critical production guardrails: two-layer deduplication to prevent alert spam, runner timeout architectures, and minimizing trust boundaries using existing CI secrets to prevent modern prompt-injection attacks.

Claude Code as a CI Job – An Edge-Triggered AI Incident Reporter for full-stack JavaScript CI/CD

Serhii Yakovenko

Automated accessibility testing libraries like axe can identify many issues, but they cannot tell you whether your product is truly accessible.We will discuss how to build a layered accessibility testing strategy using a range of tools. We will look at which issues tools like axe can reliably identify, where their limits are, how to use Playwright to add another testing layer, and which areas still require manual review.

Beyond Axe: A Layered Strategy for Accessibility Testing

Elena Darevskaya

Most JavaScript developers can ship a frontend in an afternoon. The backend could take longer, a database from one vendor, auth from another, file storage from a third, and a serverless function to hold it together. Half of it ends up in the repo. The other half lives wherever each vendor keeps it. Supabase ships the whole stack as one project, and every piece of it can live in your repo. This session is a fast-paced, demo-driven walkthrough of building a complete backend with Supabase, from an empty folder to a working app. We spin up PostgreSQL, auth, storage, and real-time locally with one command, design the schema in the dashboard with AI doing the boring parts, capture it as migrations that live in git, connect it to a TypeScript app with generated types, and finish with an agent making the next change through MCP, because now there is something for it to read.

Your App Has a Backend. Here's the Supabase Workflow You're Missing

Carlos Robles

You may be missing out on what your type system can do for you. And I don't mean learning arcane TS shenanigans!I will show you how to wield types to represent your domain in a fine-grained, self-documenting way. We will make impossible states unrepresentable. We will encode business rules as laws carved into stone before the kingdom was built, without writing a single line of runtime code.With real-world examples, together, we will forge a more functional approach to modeling your app. No monad required. No dark magic. Just the ancient craft of types, finally put to work.

Forging Your Domain: Functional Domain Modeling in TypeScript

Nicolas Carlo

You can build a pretty decent rich text editor in HTML these days. We reached the point, though, where we needed to build our own from scratch in canvas so that we could deliver better performance, better language support, and more consistency.

Why we Built Our Own Canvas-Rendered Text Editor at Miro

Ben Makuh

Is JavaScript just logic, or also an infinite brush? We'll discover algorithmic art: fractals, cellular automata, and the "Algorist". We close with a live demo where the audience's applause generates art in real time.

Infinite Patterns in the Digital Canvas

Francisca Beatriz Medina Concha

When a developer asks Claude Code or Codex to build their app and use your product, the agent is the one reading your docs, running your CLI, and deciding what to do when a command fails. We're all iterating on our MCP and Skills to improve this experience, but it's hard to actually evaluate this.We built a tool that runs these agents against real tasks in isolated sandboxes, then changes one thing at a time: CLI or MCP, skills on or off, this week's CLI release or last week's. It also separates the help an agent genuinely needs (like signing in) from the unnecessary human intervention due to a gap in the experience.We'll use those runs to look at how to design for agents: docs they can actually find, responses that point to the next step, and output they don't have to dig through.

Building an Eval System for Agent Experience Research

Tej Chilukuri

The slowest smartphone your code will ever run on is ridiculously fast in an objective sense. So why does every burrito taxi website feel like trying to run in waist-deep molasses? Gather round this here campfire for (largely anonymised) tales from ten years of <s>PWA consulting</s> performance remediation purgatory.

Groundhog Day: A Decade in the Web Performance Trenches

 Alex Russell

AI, React, Vue - what do all of these things have in common? They are tools meant to enhance the development experience - we must remember that. Join me in going over best practices on using AI to LEARN and not to do you your job for you. I’ll take you through the steps of how I used AI as a React developer to learn Vue - did I actually learn? Join this talk to find out!

AI Helped me Learn Vue through the Lens of a React Developer

Daniel Mendoza

Frontier coding agents routinely ship hundreds of lines of legacy JavaScript for UI patterns the web platform now handles natively. Drawing on Modern Web Guidance, an agent skill with 200+ web development tasks, we’ll explore why models lag behind the platform, and how to steer and verify them in practice.

Why Your Coding Agent Still Writes 2019 Web Code

Rick Viscomi

Frontend observability works much like backend observability: get a signal that something is off, investigate it, fix it, then monitor the fix. The hard part is getting those signals at scale. This talk walks through a real investigation where support tickets pointed to a frontend error that didn't make sense at first. Slicing the data by other dimensions didn't explain it. Watching session replays exposed the root cause, which was a browser translation feature rewriting the DOM out from under React. From there, the talk turns from visible failures to experiences that are simply slow. It covers how to define the critical operations in your app, measure their availability and latency, trace slow interactions to the code that causes them, and validate every deploy against your baselines. It closes with how Anthropic ran this loop to make claude.ai roughly 3x faster in two weeks.

From User Impact to Faster UI: Closing the Frontend Optimization Loop

Bridgitte Kwong

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

Modern React Architecture

Brad Westfall

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

Claude Code: Black Belt

Pawel Sawicki

Every team now has the same frontier models. Same models and similar prompts mean similar defaults, so the code your agent writes looks a lot like everyone else's. Picking a better model won't set you apart anymore. What sets you apart is what your agent knows, and whether it can prove its work.In this hands-on workshop, you'll give your coding agent two advantages. Modern Web Guidance adds expert-vetted web platform knowledge, best practices and browser compatibility data. That steers your agent towards leaner, faster, more accessible solutions instead of heavyweight defaults and outdated APIs. Chrome DevTools for Agents lets your agent open your app in a real browser with powerful DevTools capabilities to see what the code alone doesn’t show, from runtime performance and layout shifts to the accessibility tree and memory leaks. You'll compare guided and unguided agents on real features, then use the same workflow on an existing codebase.This workshop is for frontend and full-stack engineers who already use AI coding agents and want output that stands out. You'll leave with a setup that works with the agent you already use, and a repeatable way to build, check and ship work.

Agentic Web Development With Modern Web Guidance and Chrome DevTools for Agents

Tara Ojo Agyemang

Join the Nation`s space program! The conference to get updates from the authors and core teams presenting on the West largest dome screen.

JSNation US

I’m attending the main #JavaScript conference in the US. Join me and 10k other JS engineers. Follow this link to receive a free remote ticket. The theme of the year is AI for coding and the future of #WebDev.

#JSNation

JSNation US 2026

The main web dev conference in the US