June 11 - 15, 2026
Web Engineering Summit
Amsterdam & Online

Web Engineering Summit 2026

The full-stack excellence conference

Web Engineering Summit is a 2‑day, 2‑track conference for engineers building and evolving production web systems. Explore how modern web platforms are architected, scaled, observed, secured, and improved over time — with a focus on reliability, performance, quality, and developer experience. Join thousands of engineers who care not just about shipping features, but about building systems that last.



This edition of the event has finished, the latest updates of this Tech Conference are available on the Brand Website.

GitNation Events Supporter

Catch, trace, and fix bugs across your entire stack Learn more

React Query - Beyond the Basics
Workshop finished
React Query - Beyond the Basics
WorkshopPro
Dominik Dorfmeister
Dominik Dorfmeister
In this workshop, we'll go beyond the fundamentals and explore some of the more powerful features React Query has to offer. You'll gain a deeper understanding of how it works under the hood and learn how to write scalable, maintainable React Query code.Together, we'll build a simple example app and incrementally enhance it with one core objective in mind: delivering the best possible user experience. That means snappy interactions, minimal layout shifts, and avoiding unnecessary loading spinners wherever we can.To achieve this, we'll dive into advanced techniques like various forms of prefetching (including integration with route loaders), seeding the query cache, crafting smooth paginated experiences, and even persisting query state through full page reloads using persistence plugins.Note: You should have prior knowledge about React Query if you attend this workshop.
Dead Code Shouldn’t Exist: How We Removed 28k Lines of Code, One Knip at a Time
35 min
Dead Code Shouldn’t Exist: How We Removed 28k Lines of Code, One Knip at a Time
The Talk covers the importance of building a design system for efficient component usage and maintaining a clean codebase for faster shipping. It discusses the impact of unused code on development efficiency, challenges in cross-module usage analysis with TypeScript, and the use of KNIP for identifying and removing unused code elements. KNIP aids in code cleanup, optimization, and dependency removal, enhancing code cleanliness and efficiency. The Talk also addresses challenges in adapting to KNIP in CI workflows, caution in dynamic codebases, and the potential for KNIP to expand to other cleanup tasks beyond code size reduction.
Agents on the Canvas With tldraw
29 min
Agents on the Canvas With tldraw
The Talk delves into the exploration of Agents on the Canvas, integrating LLMs with visual elements and spatial relations. It covers the development of the Agent Starter Kit for navigating Canvas tasks and introduces fairies as collaborative agents. The discussion includes managing tasks, utilizing Cloud Code for project collaboration, creating interactive UIs, and customizing UI components. The evolution of agentic canvas code, agent interactions, user actions, token usage, and data handling with LLMs are highlighted, emphasizing experimentation and optimization for SDK integration.
Chunking
28 min
Chunking
Tobias Koppers from Vercel explains the process of chunking in bundlers and its impact on module organization and loading efficiency. Optimization strategies involve analyzing metrics, chunk groups, request counts, and long-term caching for better performance. Managing trade-offs in chunking with long-term caching, correctness, and CSS order considerations is crucial. Challenges include implicit CSS dependencies, overshipping, and balancing CSS ordering for future optimizations. Compile time complexities and future optimization challenges highlight the evolving nature of chunking strategies.
Stress Test Your Reflexes (And My App)
32 min
Stress Test Your Reflexes (And My App)
Eddie from PayPal introduces a Whack-A-Mole game to discuss real-time data and engage the audience. Real-time data is essential for dynamic updates and efficient data handling. Challenges with AI-generated MVP led to a successful times three model with real-time features. The evolution of data communication technologies from Comet to WebSockets is highlighted. Transition to WebSocket native implementation for efficiency and benefits of using Superbase are discussed. Real-time features in games, event handling, presence tracking, and event broadcasting are explored. React SDK, real-time tools, scalability with Meteor, and managing data noise are addressed in the Q&A sessions.
Voice Agent Bootcamp: Build Production-Ready Agents from Scratch
130 min
Voice Agent Bootcamp: Build Production-Ready Agents from Scratch
Workshop
Jesse Hall
Jesse Hall
Ready to go from zero to deployed voice agent?Voice AI is moving fast, but most tutorials end at "hello world" and leave you wondering how to actually ship something to production. This intensive workshop takes you through the entire journey: building a complete voice agent with TypeScript and React, deploying it to production, setting up observability, and creating evaluation frameworks—all the pieces you need for real-world JavaScript applications.What you'll build:A full-stack voice agent using LiveKit's TypeScript SDKReact UI with real-time audio visualization and state managementProduction deployment with proper observabilityAutomated testing and evaluation frameworksTopics covered:Setting up WebRTC audio streams with TypeScriptIntegrating STT, LLM, and TTS models in your JavaScript stackBuilding React UI for voice interactions with real-time stateHandling interruptions and natural turn-takingDeploying to production (Vercel)Setting up observability and session replayBuilding evaluation frameworks for quality assuranceThis isn't a demo – it's a bootcamp. You'll write TypeScript code, debug issues, and deploy to production. By the end, you'll have a working voice agent and the confidence to build more.
DevOps for Front-end Developers: From Local Code to Production by Docker Captain
Workshop finished
DevOps for Front-end Developers: From Local Code to Production by Docker Captain
WorkshopPro
Kristiyan Velkov
Kristiyan Velkov
Mentorship available
Many front-end developers build modern applications with confidence, but struggle when it comes to shipping those applications to production. Docker, CI/CD, environment configuration, performance tuning, and deployment often remain “someone else’s job” — until something breaks and becomes your responsibility. This workshop closes that gap.
It’s a practical, production-focused workshop designed for front-end developers who want to take full ownership of their front-end applications — from local development to stable, production-ready deployments.

You’ll learn how to:
Dockerize front-end applications for both development and productionCreate optimized, production-ready Docker images for modern front-end frameworksOptimize front-end applications for performance, stability, and reliabilityAvoid common production mistakes seen in real-world front-end projectsDocker for Front-end Developers is a practical book designed specifically for front-end engineers who want to truly understand and confidently use Docker in real-world projects — written by Docker Captain and author of the official Docker React.js sample documentation Kristiyan Velkov — with 30% off using code DOCKER30.
Building Fullstack Apps With Cursor
164 min
Building Fullstack Apps With Cursor
Workshop
Maurice de Beijer
Maurice de Beijer
Direct the code. Don't just write it.The development landscape is shifting from manual coding to system orchestration. Whether you are a seasoned React engineer looking to 10x your output or a product-driven creator aiming to turn a prototype into a functional app, this workshop is your gateway to AI-native development.Join us for a hands-on, 4-hour masterclass where we build a feature-rich, fullstack application from scratch using Cursor Composer. We skip the boilerplate and focus on the exact workflows used to ship high-quality features in minutes, not days.What You’ll MasterAI Orchestration: Move beyond simple autocomplete to manage multi-file changes and complex app logic.The .cursorrules Framework: Learn how to enforce project standards and prevent AI "hallucinations" for consistent, professional code.Rapid Fullstack Scaffolding: Generate type-safe database schemas and backend logic instantly.High-Fidelity UI Iteration: Transform prompts into polished, responsive interfaces using modern CSS and component libraries.Hardening & Refactoring: Use AI to hunt bugs, clean up "spaghetti" code, and generate comprehensive test suites.The ProjectWe will build a modern, data-driven web application that demonstrates the power of AI-assisted development. By the end of the session, you will have a functional codebase that showcases complex data relationships, dynamic UI, and optimized state management.
Who Is This For?Developers who want to eliminate repetitive tasks and focus on high-level architecture.Founders & Prototypers who need to bridge the gap between an idea and a working product rapidly.Tech Enthusiasts eager to master the professional AI-native toolkit.Requirement: Bring a laptop with Cursor installed. We provide the roadmap; the AI provides the speed; you provide the vision.
As this is a live online session, we encourage you to sign up ASAP to receive the pre-workshop setup guide and ensure you are ready to build from minute one.
How I Taught LLMs How to Svelte
33 min
How I Taught LLMs How to Svelte
The talk by Paolo Ricciuti introduces Svelte framework basics, syntax evolution in Svelte 5, challenges with LLMs in Svelte, Model Context Protocol (MCP) for LLMs, utilizing MCP for code verification, enhancements with Svelte MCP CLI, Svelte benchmark creation, integration of agent skills in node modules, Svelte adoption and DX differentiation, and Svelte autofixer and MCP linter.
Templates and Components for Claude Code: The Future of AI Coding Workflows
30 min
Templates and Components for Claude Code: The Future of AI Coding Workflows
Daniel Avila discussing templates and components for Cloud Code, emphasizing the importance of configuration settings and skills integration in the development process. Cloud Code settings, commands, sub-agents, and skills integration play a crucial role in developing a complete template for AI agents. Skills injection, documentation, development template, Cloud Code components sharing, harness engineering, logs review, process improvement, configuration levels. Configuration levels, settings.json, hooks, verification, deterministic projects, templates, status lines, cloud.md, best practices. Explaining skill invocation control, model usage, and skill specialization for message crafting within commits. Emphasizing the importance of managing the context window effectively for skill injection and understanding the interaction with various agents and tools.
Operating Agent-Based Systems - Overview, Configure, Run, Orchestrate, Monitor
129 min
Operating Agent-Based Systems - Overview, Configure, Run, Orchestrate, Monitor
Workshop
Alex Korzhikov
Pavlik Kiselev
2 authors
This workshop explores how standalone agents operate at the runtime level and how they differ from traditional AI pipelines. We’ll examine agent architecture, planning loops, memory models, and tool execution. We’ll also cover multi-agent coordination, including state isolation and resource control. A key focus is security and governance — capability-based access, sandboxing, and injection risks. Finally, we’ll address observability and supervision: tracing reasoning, auditing tool usage, and implementing control mechanisms for production systems.

All examples and concepts will be grounded in the Node.js stack and we will explore why Node.js is particularly well-suited for building production-ready agent runtimes — serving as the control plane for supervision, integration, streaming execution, and distributed coordination.

References: OpenClaw, n8n, LangChain.
Autonomous AI Agents in Action With the Ralph Wiggum Method
28 min
Autonomous AI Agents in Action With the Ralph Wiggum Method
Today's Talk delves into the Ralf Wiggum method for autonomous AI agents, emphasizing persistent looping based on specifications in AI coding. It addresses context management challenges in AI chats, promotes optimized coding workflows with feedback loops and engineer decision-making. Automation of specifications and task implementation is highlighted, alongside interactive conversation, prototyping, and managing code implementation. The importance of code quality enhancement, exploring new approaches with AI coding agents, and ensuring smart application of AI tools is discussed. Utilizing impactful skills and convincing leadership with results from the Ralph method are key points, along with enhancing task efficiency and overcoming tool limitations for efficient work.
Building AI-Powered Apps with TanStack AI - From Setup to Chat Tools
Workshop finished
Building AI-Powered Apps with TanStack AI - From Setup to Chat Tools
WorkshopPro
Alem Tuzlak
Alem Tuzlak
In this hands-on workshop, you’ll learn how to integrate AI directly into your application using TanStack AI. We’ll build a working AI chat feature end-to-end, starting from server setup and finishing with a streaming client, tool calling, human-in-the-loop workflows, and real debugging using TanStack DevTools.

Through guided exercises, you’ll learn how to set up TanStack AI on the server, connect a client application to a streaming AI backend, build a functional chat interface, create your first AI tools, and implement approval flows so humans can stay in control when tools are invoked.

By the end of the session, you’ll understand the core building blocks of AI-powered applications and walk away with a solid foundation for adding intelligent chat and tool capabilities to your own apps.

Workshop outcomesWhen you're finished with this workshop you will:Understand how to set up TanStack AI on the server and wire it to a provider (like OpenAI)Know how to connect a client app to a streaming AI endpoint and handle incremental updates cleanlyBuild a functional chat UI with a solid state model for messages, streaming tokens, and tool resultsCreate and use your first AI tools with clear inputs, outputs, and predictable behaviorBuild human-in-the-loop workflows with tool approvals so your app can ask for confirmation before executing sensitive actionsDebug and inspect your AI app using TanStack DevTools, including tool calls, responses, and streaming behaviorWhat you'll learn

TanStack AI gives you the primitives to build real AI features, not just a demo prompt box. This workshop focuses on wiring everything together properly, from server-side streaming to client UX, then layering in tools, approvals, and debugging so the final result is something you can confidently evolve into production features.

You’ll learn the following through these exercises:Server setup - Configure TanStack AI on the server, connect to your model provider, and expose endpoints that support streaming chatStreaming and SSE - Implement and consume streaming responses, understand the lifecycle of a stream, and build UI that stays responsive while tokens arriveChat UI and state - Build a chat interface that handles message history, partial responses, loading states, and tool outputs in a clean wayTools - Define tools, validate inputs, return structured outputs, and integrate tool results back into the conversation flowHuman in the loop - Add approval steps for tool execution, implement “approve/deny” flows, and keep users in control when actions matterDebugging with TanStack DevTools - Inspect requests, responses, tool calls, timing, and streaming behavior so you can troubleshoot fast and iterate safelyPrerequisites

This workshop assumes you can build and run a React + TypeScript app locally and you are comfortable working with a basic server setup.Basic understanding of SSE and streaming is required (we’ll use streaming heavily throughout the workshop)Experience with React is required (components, state, props, rendering lists)Basic TypeScript knowledge is required (we’ll rely on types for tools and structured outputs)You will need an OpenAI API key with available credits to use during the workshop exercises
Walking the Netflix Paved Road (Bumps Included): Web Framework, Hawkins Design System
26 min
Walking the Netflix Paved Road (Bumps Included): Web Framework, Hawkins Design System
Misha, a UI engineer at Netflix, discusses challenges faced by the UI platform and product team. Platform tooling and migration benefits focus on boosting productivity and efficiency. Tool selection and platform transition involve analyzing and bundling tools for streamlined processes. Legacy setup and community libraries highlight the complexity of pre-UiPR setups. Phased migration approaches and component transitions emphasize reducing technical debt and collaboration. Leadership justification, team collaboration, and UI framework creation and regrets are also key points discussed.
Using Spec-Driven Development for Production Workflows
19 min
Using Spec-Driven Development for Production Workflows
Eric Hanchett discusses spec-driven development, emphasizing structured code creation with specifications before writing any code. The importance of context in guiding large language models and the evolving nature of software development is highlighted. Kiro, an AI IDE coding assistant, offers a comprehensive solution for improved spectrum development processes. Kiro's focus on vibe and spec mode caters to the need for working on larger and more complex projects. Spec-driven development in Kiro is beneficial for in-depth features and structured project building. The discussion also includes property-based tests, MVP creation, and the Model Context Protocol (MCP) integration within the spec-driven development flow.
No Servers, No Cloud, No Masters: Make P2P Apps
32 min
No Servers, No Cloud, No Masters: Make P2P Apps
Working on decentralized peer-to-peer technology without infrastructure, enabling JavaScript apps to be deployed peer-to-peer without servers or cloud. Refining technology for four years, partnership with Tether, launch of Keet app for peer-to-peer connection using hole punching algorithm. Built with PAIRS stack for robust, cost-effective technology. BEAR - minimal Node-like runtime for peer-to-peer. PeerRuntime module enables peer-to-peer updates and simple primitives. Dual-distribution model for app deployment with peer-to-peer updates and cost savings. React Native boilerplate for mobile apps with peer-to-peer updates. Predators infiltration risk in peer-to-peer. Local devices turning into peers for updates.
Building a JavaScript Engine in Rust: Lessons From Boa
24 min
Building a JavaScript Engine in Rust: Lessons From Boa
Jason Williams discussed building a JavaScript engine in Rust, focusing on challenges and achievements with Servo, including making Servo work on Windows. Boa was introduced as a JavaScript engine project with a blog on Mozilla Hacks. Boa's development stages were highlighted, starting from file reading and tokenization. The talk delved into token types, lexical declarations, parsing, and execution methods in Boa. Community involvement, testing emphasis, and conformance achievements were emphasized, with a notable collaboration on Temporal implementation reaching 100% test pass rate.
Let’s Teach Neo Kung-Fu: Building an Agentic Skill with MCP Tools
60 min
Let’s Teach Neo Kung-Fu: Building an Agentic Skill with MCP Tools
Workshop
Misha Kazakov
Misha Kazakov
AI coding assistants are evolving from simple autocomplete to autonomous agents that can interact with external systems. But how do you teach an agent to follow your workflows and use the right tools at the right time?In this hands-on workshop, you'll discover:What MCP (Model Context Protocol) is and how it standardizes tool integration for LLMsHow Agent Skills package domain-specific knowledge and workflows for AI agentsThe key differences between MCP servers and Skills, and when to use eachHow to create a custom Skill that orchestrates multiple MCP tools into a cohesive workflowBy the end of this session, you'll build your own AI Skill that uses MCP tools — a Matrix-themed Neo fighting skill.Who should attend: This workshop is ideal for software developers who use AI coding assistants (Claude Code, Cursor, or similar) and want to extend their capabilities with custom integrations and workflows. No prior MCP or Skills experience required — just bring your curiosity and a laptop.
FullStack Monitoring with Open Telemetry: End-to-End Observability for Modern Applications
30 min
FullStack Monitoring with Open Telemetry: End-to-End Observability for Modern Applications
The speaker discusses the importance of performance development in AI applications, concerns about application crashes and vulnerabilities, utilizing data for performance improvement, application monitoring with OpenTelemetry, integrating AI for enhanced security measures, streamlining data analysis and reporting, leveraging AI for security threat detection, optimizing data logging, and involving data experts for determining data importance.
Agentic Interfaces: Tools, Skills, Generative UI and Web MCP
31 min
Agentic Interfaces: Tools, Skills, Generative UI and Web MCP
Wes discusses agentic interfaces and the changing interaction with the web. Exploring different software interfaces from UI-less to tailored interfaces and interconnected apps. Implementation options include generative UI with basic, declarative, and fully generative levels. Exploring the challenges of integrating unconventional components like wacky shopping lists and the need for a balance between dynamic and fully generative components in user interfaces. Exploring the shift from fast interactions to slower MCP interfaces, emphasizing the need for adaptive Smart Home systems and user-centric interfaces. Excitement about WebMCP, enabling extended website functionality through WebSemantics and imperative JavaScript API. Utilizing agents for enhanced website control, switching between Cloud and browser for varied experiences. Impact of evolving technology on business adaptation and the shift towards platform control. Discussion on the future of dynamic UI with user-driven component rendering and the importance of preserving the openness of the web amidst AI-driven application generation. Contemplation on the effectiveness of MCP-based interactions as AI companies transition to charging for services, hinting at potential cost implications in the near future.
MemLab: Automating Memory Leak Detection and Heap Analysis
19 min
MemLab: Automating Memory Leak Detection and Heap Analysis
Liang introduces MemoryLab, a tool for automating JavaScript memory leak detection. MemoryLab aims to make memory debugging more accessible and scalable by automating the process and utilizing a three snapshot differentiation approach. It clusters similar leak traces to reduce debugging overload and presents representative cluster retainer traces for each memory leak cluster. MemoryLab integrates AI coding tools for memory detection, analysis, and debugging, with the MCP server enabling accurate investigation of memory leaks in heap snapshots.
Advanced Claude Code — Production Workflows, Subagents, and Autonomous Execution
207 min
Advanced Claude Code — Production Workflows, Subagents, and Autonomous Execution
Workshop
Aleksei Petrov
Aleksei Petrov
Most developers using AI coding tools hit the same wall on real projects: the demos look magical, but production work falls apart. This workshop shows why — and what to do about it.The core lesson: execution is fast and cheap only when preparation is deep.What we'll build, liveFrom an empty directory to a deployed production app — a mobile-first Conference Companion App with the event schedule, speaker profiles, search, and favourites. Attendees will open it on their phones before the session ends.
The four stages of shipping with AIYou'll see a complete production workflow, deliberately weighted toward the work that actually determines quality:- Research — Gathering everything the AI will need upfront: official docs, code patterns, real data. By execution time, nothing has to be searched for. This is where quality comes from.- Planning — Breaking the app into clear tasks with acceptance criteria, written live. Skipping this is why most AI builds fail.- Execution — Ten tasks running in parallel via git worktrees, orchestrated by Navigator (a Claude Code plugin) on a React/Next.js stack. Code and docs written together.- Review & Ship — Quality gates (tests, lint, types, build), clean commits, merge, deploy to Vercel. Live URL shared with the room.
Bonus: Human + Claude Code vs. fully autonomous agentWhile the live build runs, Pilot — our autonomous coding agent — builds the same app from the same spec, on its own, in a separate repository. At the end, we open both side by side: two working apps, two pull request histories, two live URLs. One human-driven, one fully autonomous.
You'll leave withA repeatable workflow for shipping real software with Claude Code, plus concrete techniques you can apply to your own projects on Monday morning.
Creating a Design System for 1B+ Users in the Age of AI
25 min
Creating a Design System for 1B+ Users in the Age of AI
Noe Yamamoto, a UI engineer, shares his journey from Squarespace to WhatsApp, highlighting a passion for UI. WhatsApp Web has evolved to a feature-rich platform with a consistent design language. Engineers face challenges in maintaining design consistency and feature parity with mobile. They also encounter issues in identifying design inconsistencies and usability problems. A UI refresh in 2024 brought significant design improvements, with positive user feedback. Legacy component management and AI integration present challenges, as does initiating and evolving the design system. Community-driven design systems and AI integration are emphasized, along with testing approaches and the importance of accessibility in design systems.
Open Source Voice AI: How We Built ChatGPT's Voice Mode Infrastructure
20 min
Open Source Voice AI: How We Built ChatGPT's Voice Mode Infrastructure
Voice interaction is evolving rapidly with AI agents moving beyond chat windows. Achieving natural conversations with voice AI presents significant challenges, especially in meeting real-time interaction expectations. Advancements in real-time conversation technology and infrastructure are improving latency gaps in voice apps. Optimizing latency at each stage of voice agent processing is crucial for efficient development. Semantic turn detection and efficient function calling are key to optimizing user experience in Voice AI. Workflow management, cost management, signal recognition, and observability are vital aspects in voice AI development.
AI Can Generate Tests for You, Now What?
22 min
AI Can Generate Tests for You, Now What?
Living in an exciting and productive period with AI's assistance in test generation and scalability, led by Maya, a Staff Software Engineer passionate about AI accessibility. Streamlined test generation through AI can compromise code quality if not placed correctly, emphasizing the importance of test validity over quantity. Challenges of test generation include cost impacts on code quality, highlighting the need for validity over quantity and the importance of placing tests correctly. Understanding risks and validation criteria in code testing, with an example focusing on search functionality. Importance of mapping tests to specific quarens for effective validation in Agile Testing. Exploring AI integration into Agile Testing, balancing AI and human input for effective workflows. Transitioning to a new scalable workflow with AI test plan generation for enhanced efficiency. Establishing collaboration standards with AI, prioritizing strategic testing tactics over quantity and ensuring code safety beyond complete coverage.
How We Used AI to Build TanStack AI
33 min
How We Used AI to Build TanStack AI
Zalim Tuzlak explains features of building 10 stack AI, enhancing capabilities with middleware and tool code mode, efficient AI tool script writing, challenges and breakthroughs in AI development, building scalable AI tools with activity-based tree shaking, early AI concepts and code quality strategies, empowering rapid AI iteration, TensTech AI beta release with Angular support, AI model comparison and evaluation, AI SDK features enhancement, quality assurance processes for TanStack AI docs, personal stress and decision fatigue in AI development, challenges in middleware development with AI assistance, skill creation process within the team, and TanStack AI's end goal and selling point.
Pear: Releasing Production P2P Apps
54 min
Pear: Releasing Production P2P Apps
WorkshopFree
David Mark Clements
Mikkel Malmberg
2 authors
All it takes is a module and a CLI tool to build and deploy production peer-to-peer applications. In this workshop:Build a realtime peer-to-peer applicationConnect with others on your own application, completely peer-to-peer.Understand how to deploy, including production practices, principles and toolingThis is for anyone who builds with JavaScript and anyone who deploys applications.
HTML in Canvas: Bridging UI and GPU on the Web
17 min
HTML in Canvas: Bridging UI and GPU on the Web
Santiago Colombatto
Tomas Ferreras
2 authors
Santiago Colombato discusses challenges in synchronizing DOM and WebGL for visually heavy websites, focusing on scroll sync and basics of WebGL's rendering process. The talk addresses the complexities of rendering text on GPU in WebGL and the challenges of HTML in canvas implementation. The proposal introduces advanced features like a paint event and element image capture to enable synchronization of HTML changes and element snapshots. Exciting prospects include blurring the lines between DOM and canvas, showcasing 3D scenes, distorted text, and GPU effects, offering new possibilities for website generation.
Supercharging Your Tooling With Rust
24 min
Supercharging Your Tooling With Rust
Mael discusses the evolution of Yarn from its origins in 2016 to the current version being developed in Rust. Yarn's stability and familiarity with the codebase led to the decision to build Yarn 6 in Rust, despite challenges faced with previous rewrites and limitations of Yarn 4. Large companies using Yarn faced latency issues due to the number of workspaces. Yarn aimed for improved performance with features like lazy install to enhance user experience. Yarn aimed to be exceptionally fast, catering to various ecosystems beyond JavaScript, like Python and Rust, to enhance usability. Yarn faced challenges with breaking changes and friction during the rewrite to Yarn 2, emphasizing the importance of careful implementation in Yarn 6's development. Learning a new language was a key part of the rewrite process, with significant progress in test passing and personal proficiency in Rust. Developing in Rust led to a growth in personal proficiency and revealed insights into Rust's tooling and concurrency benefits. Rust revealed experimental features and concurrency benefits, requiring mental model shifts. Rust's human-written code rewrite with AI assistance. Challenges of integrating Yarn rewrite with Rust version and freezing main branch for rewrites. Considerations for rewriting projects in Rust, YARN's improved performance, and the importance of motivation and resilience in such endeavors. YARN's expansion to support multiple ecosystems and the invitation to engage in devlogs and share feedback on the talk and rewrite.
LLM Powered Migration of UI Component Libraries
25 min
LLM Powered Migration of UI Component Libraries
Nawal discusses using LLMs for migrating component libraries at Zalando, highlighting challenges and complexities. Discussing a recent migration problem at Zalando involving unification of component libraries and challenges in automating migration process. Encountering limitations with codemods, leading to exploration of LLMs for automated migration processes. Conducting iterative experiments to enhance LLM accuracy in component migration. Building a CLI tool for component migration. Using AIDAR for automating git commits & maintaining LLM accuracy. Recommendation for team closeness to code, successful complex transformations by LLM, challenges with hallucination and ignoring instructions. Lessons learned include field addition, non-deterministic outputs, slow responses, project constraints, and tool evaluation. Evaluating tool enhancements, PROMPT best practices, core approach, improved tools, LLMs for simple migrations, and tool limitations with multiple file changes.
Click. Ship. Done. AI Agents on Cloudflare
22 min
Click. Ship. Done. AI Agents on Cloudflare
AI evolution from the past to present, showcasing advancements like ChatGPT for easier programming accessibility. Generative AI advancements with ChatGPT, followed by rapid evolution in coding accessibility and introduction of innovative AI models like Zorro by OpenAI. User input processed by LLM in chatbot scenarios. Agentic loop adds steps for evolution and manipulation in processing prompts. LLM guides steps in user interaction. MCP's role in LLM operations and potential challenges of self-hosting agents. Future uncertainty in self-hosting with Cloudflare workers and utilizing durable objects for state storage in APIs. Interactivity improvement with durable object storage in Cloudflare workers and the integration of AI chat agents for message handling. Accessing LLM models, utilizing screen text for message handling, integrating MCP tools, and deploying AI chat agents on Cloudflare. Deploying AI chatbots on Cloudflare, connecting to MCP servers, and handling prompts from GitHub MCP. Configuring MCP server tools, deploying with wrangler, and exploring Cloudflare agent setup. Setting up Cloudflare chat agent, deploying with wrangler, leveraging Cloudflare tools for efficient deployment. Setting up Cloudflare chat agent with efficient deployment using wrangler deploy command and GitHub integration. Easily interact with AI chat agent and other functionalities on Cloudflare.
Orchestrating Content Workflows at Netflix Scale
20 min
Orchestrating Content Workflows at Netflix Scale
Pradeep Shah, senior software engineer at Netflix, discusses the coordination of rule engines, ML models, and humans in content understanding infrastructure. Building an extensible system based on a shared framework derived from past workflow challenges. Implementing a two-tier architecture for state management and workflow execution using Conductor. Utilizing Conductor for orchestration with retries, timeouts, and parallel execution. Workflow onboarding steps include defining triggering events, task creation, lifecycle tracking, and human intervention for AI confidence below threshold. Human decision structured output, model feedback pipeline, and domain-agnostic schemas for reusability. AI agent service mirrors human process, seamless AI integration, and architecture success factors: separation of concerns, pluggability, multi-modal workers, and human corrections as training signals.
Stop Using JSON Web Tokens (JWTs) for Authorization!
12 min
Stop Using JSON Web Tokens (JWTs) for Authorization!
Sohan Maheshwar humorously recounts feedback on advising against JWTs for authorization, highlighting challenges in payload structure and fine-grained permissions. Scalability and token revocation present issues, along with predicting permissions. Risks of overprovisioning permissions are addressed, with Macaroons as a solution and complexity in access control systems. Modern authorization systems like Zanzibar and Policy Engine prioritize correctness, flexibility, and security over simplicity of JWTs.
From 8 Years to 6 Months: Orchestrating AI Agents for Large-Scale Refactoring
29 min
From 8 Years to 6 Months: Orchestrating AI Agents for Large-Scale Refactoring
Alon Segal
Amit Hanoch
2 authors
We see how Monday used AI to break down a decade-old client-side monolith into micro-frontends, ensuring a complex software with long sessions and open tabs remained functional. The AI tool, Morphix, autonomously split prompts and validated tasks for consistent execution. The team focused on safe code migration, automated PR merging, and collaboration between AI and humans. They also optimized PR reviews, leveraged MorphX for monorepo restructuring, and managed AI costs effectively during the extraction process.
Halving Your CI Pipeline – Practical Optimisation Strategies
10 min
Halving Your CI Pipeline – Practical Optimisation Strategies
Serhii discusses optimizing CI pipelines, reducing pipeline time by 64% through structured approaches. Challenges in CI health, high failure rates, and the importance of trust in the system are highlighted. Prioritizing impactful optimizations, instance migration choice based on variance impact, and optimizing test environment sizing for efficiency. Reclaiming resources, optimizing CI processes, and enhancing stability through strategic changes. Building an advanced test retry system to enhance CI health and save costs. Key takeaways: Measure before optimizing, prioritize by return, optimize the whole system for improved efficiency and coverage.
Think Like a Tester: What to Look For in AI-Generated Code
16 min
Think Like a Tester: What to Look For in AI-Generated Code
Developers write code to make things work. Wendy, QA Automation Engineer, introduces John, a great developer who encounters challenges implementing a new feature. Checkout is critical for the company's existence, emphasizing its importance. When a coupon expires, issues arise with discounts. John faces challenges fixing the code, revealing different perspectives between developers and testers. Developers and testers are partners balancing each other's perspectives. Introducing the QAI for adding QA insights to development processes. Ensuring code matches agreements is crucial. Phase B scans code for potential issues. Code alignment is the gate to address discrepancies between agreements and code. Product oversight in code scenarios. Code failures can be concealed and dangerous. Handling hidden failures is crucial in code development. User faced invisible failures; handled vs. hidden code distinction. Fast code requires a security lens and skepticism. Trust gap between front end assumptions and back end validations. Distinguishing code gaps; AI lacks awareness; critical accessibility issues; distinct code failure types with separate focuses. Utilizing team patterns for efficiency; AI effectiveness through direction with QAI; improving code quality with QAI assistance. Contradiction between PRD and Figma resolved by John; Efficient bug fixing and code scanning; Enjoying exploring edge cases and unique challenges. Importance of clean code for efficient development; Addressing bugs at the right time saves resources; Transition from bug finding in development to production.
The State of AI for Web Development
35 min
The State of AI for Web Development
Sasha discusses AI for web development, based on web dev AI survey results. AI's pervasive presence highlighted through personal experiences and industry trends. Increase in AI usage reflected in code generation and refactoring practices, impacting workflows and costs. Top pain points of AI tool usage include hallucinations, inaccuracies, and rising financial costs. Concerns about AI impact on job security, gender divide in environmental impact perception, and Moore's Law implications on rising AI costs. Speculation on faster, cheaper AI future, self-evolving code, and digital immune system. Software evolution towards probabilistic systems, personalized codebases, and digital DNA. AI potentially controlling digital lives, rendering software tools obsolete, and prompting critical thinking on future implications. Insights from AI survey results showcasing AI usage trends based on experience levels. Surprising impact of AI usage and philosophical views on AI terminology. Implications of AI advancement on coding skills, adaptation of software skills for the AI era, and concerns over AI-generated tech debt and social impacts. Speculation on AI tokens as global currency, ethical considerations, and impact on coding skills. Contemplation of AI future consequences and preparation for potential outcomes.
Building ChatGPT and MCP Apps with All the Comfort of Modern TypeScript DevX
21 min
Building ChatGPT and MCP Apps with All the Comfort of Modern TypeScript DevX
Fred, CTO of ALPIC, discusses MCP hosting, Skybridge framework, MCP evolution, and partnerships with major clients like OpenAI and Google. ALPIC has developed apps for the growing ChildGPT and Cloud Connector ecosystems. Skybridge, an open-source framework, facilitates easy app development. Explore various applications like the cottage app in the chatGPT ecosystem. Build and deploy apps using Skybridge and interact with the MCP server efficiently. Develop tools to view detailed information and deploy ChatGPT apps with Alpik Tunnel for easy access and testing.
Life of an ESM in Node.js – and How It's Changing for the Better
29 min
Life of an ESM in Node.js – and How It's Changing for the Better
Talk covers the life of an ESM in Node, import resolution, module loading improvements, TypeScript transpilation challenges, customization of module resolution and source loading, handling compilation and dependencies, ESM customization, ESM limitations, circular dependencies, and optimizing loading performance in Node.
Auth Under Attack Catching JavaScript Auth Failures in Production Fast
21 min
Auth Under Attack Catching JavaScript Auth Failures in Production Fast
Viola, senior software engineer in London, presents Auth Under Attack to catch JavaScript auth failures in production fast. Auth failures lead to trust state disagreements. Tracing trust boundaries is crucial for accurate investigations. Understanding common failure shapes aids in recognition and resolution. Ensuring strong recovery flows and controls for trust extension are crucial. Permission leaks can occur when old authority persists. Focusing on system inconsistencies and broken trust chains is crucial for diagnosis and resolution. Mapping the system before implementation accelerates issue detection. Groundpact aids in enforcing authentication contracts pre-production, enhancing system security. Authentication aims for consistency and predictability, with CI as a crucial checkpoint to prevent incidents.
400 Tech Leads. Same Problems. None of Them Technical
17 min
400 Tech Leads. Same Problems. None of Them Technical
Henri Fischer discusses tech lead challenges, emphasizing the importance of defining the tech lead role and addressing time management issues through delegation. Transitioning from a driver to a support role in one-on-one meetings improves efficiency and accountability. Strategies for effective feedback, delegation, and process management include reducing fear, setting clear expectations, and ensuring clear ownership for successful project management.
MCP Apps – the Next Web
33 min
MCP Apps – the Next Web
Liad Yosef
Ido Salomon
2 authors
The Talk discusses the evolution of MCP-UI, its partnership with OpenAI and Anthropic, and its adoption by early adopters like Shopify. It emphasizes the community-driven maintenance and support of MCP-Apps, transmitting UI over MCP, and standardizing app communication with hosts. The exploration of interactive UI components, real-time model interactions, and the revolutionization of web experiences with UI chunks are highlighted. The Talk also delves into enhancing user experiences with adaptive apps, future directions for MCP apps, global reach, security measures, developer control, user engagement, and integration of MCP apps with WebMCP.
Scaling JavaScript Monorepos at Enterprise Level: Lessons From 200+ Packages
22 min
Scaling JavaScript Monorepos at Enterprise Level: Lessons From 200+ Packages
In the Talk, the most interesting ideas revolve around improving CI speed for over 200 monorepos by addressing waste in the CI process. Strategies include streamlining compilation processes, optimizing deployment by compiling only affected applications, and configuring self-hosted runners with S3 cache to enhance CI pipeline efficiency. Furthermore, enhancements in cache implementation, micro frontend build efficiency, and decoupling translations from CI to parallelize tests and reduce build and test times stand out as key points discussed.
A Brief History of Code Review (And What's Next)
8 min
A Brief History of Code Review (And What's Next)
The speaker delves into the history of code review, highlighting the Fagan inspection process from the 1990s. Code review processes evolved from print-based reviews in the 1990s to collaborative online reviews via emails and diff tools in the 2000s. The modernization of code review processes includes the shift to pull requests with GitHub, challenges of increased PR reviews in the remote work era, and the role of AI in providing instant feedback on code quality. The future of AI-augmented code review envisions an asynchronous process with AI agents offering feedback through various channels, including CLI usage, and CodeRabbit's innovative approach to code review tools.
Taking a Dump: Using Heap Dumps to Find and Fix NodeJS Memory and CPU Problems
22 min
Taking a Dump: Using Heap Dumps to Find and Fix NodeJS Memory and CPU Problems
Dan Shapir introduces heap dumps to identify and fix Node.js memory and CPU issues. Memory leaks in JavaScript occur when objects are still reachable, impacting memory usage. Continuous memory rise from leaks can deplete memory and lead to CPU usage escalation. Detecting and resolving memory leaks promptly is crucial to prevent system unresponsiveness in production environments. Heap dumps and memory dumps help analyze memory issues, with Chrome DevTools aiding in finding memory leaks. Pinpointing memory leaks involves comparing heap snapshots and analyzing leaked objects. Alternative methods for generating heap snapshots include new experimental node flags, automatic triggers, and built-in APIs, offering benefits but posing risks such as potential crashes and security vulnerabilities.
De-bloating the Web: The "Ecosystem Performance" Initiative (e18e)
20 min
De-bloating the Web: The "Ecosystem Performance" Initiative (e18e)
The E18E initiative aims to modernize the JavaScript ecosystem by addressing redundant, bloated, and unmaintained packages. It focuses on reducing dependencies, upgrading packages, and improving project performance. Collaborators have successfully reduced package sizes and enhanced tools like Storybook and Prettier CLI. Tools like TinyGlobby and E18E CLI streamline dependency management for better project efficiency. Security enhancements, frontend alternatives, and collaborations with industry players are key aspects of the initiative's development. Future plans include tool enhancement, data visibility, and ongoing collaborations.
Out-of-Order Streaming – The Future of Web Development
26 min
Out-of-Order Streaming – The Future of Web Development
Exploring web rendering evolution, limitations of server-side rendering, shift towards client-side rendering with JavaScript injection, evolution towards single-page applications with dynamic HTML generation, transition to server-side rendering, optimizing server-side rendering through hydration, partial hydration for efficient dynamic component rendering, server-side component rendering with external API data fetching, enhancing server-side rendering with streaming for improved response time, exploring sequential rendering for order control, implementing loading states with suspense and out-of-order streaming, integrating out-of-order streaming for efficient content replacement, optimizing streaming and browser functionality for seamless transitions and richer loading experiences.
Rewrite or Refactor? How to Safely Move Legacy Apps to Modern Frameworks
21 min
Rewrite or Refactor? How to Safely Move Legacy Apps to Modern Frameworks
Sylwia Laskowska discusses challenges of frontend legacy migration, importance of legacy system migration for security and performance, considerations for big bang migration strategy, success story of Angular migration, incremental migration with strangler pattern, real-life migration story using feature flags, pitfalls in migration like prolonged timeline, and migration planning and execution strategies likened to renovating an old house.
Browser, API and Assistive Technology: A Love Triangle
28 min
Browser, API and Assistive Technology: A Love Triangle
Speaker at JS Nation in Amsterdam excited about the accessibility journey discussion. Emphasizes the research journey and accessibility relationship between companies and desktop journey. Importance of understanding browser's role in accessibility testing. Browsers create accessibility trees based on W3C guidance. Overview of platform APIs like AX API, UI automation, and iAccessible2. Complexities in browser, screen reader, and platform API combinations. Challenges with Chrome and Firefox interactions. Significance of bug reporting and centralized testing platforms for accessibility. ARIA attribute challenges and overlabeling issues. Promoting accessibility as a priority in companies. Initiating accessibility programs and promoting awareness through empathy labs. Using engaging conversations and empathy-centered approach for accessibility improvement.
The Latest From Deno
29 min
The Latest From Deno
Leo from Dino talks about building desktop apps with Deno, transitioning web apps effortlessly, converting with various frameworks, and customizing easily. Experience app building with rdino desktop, live modifications with HMR flag, and the concept of transforming web apps into desktop apps. Deno offers bindings for efficient data transfer, lightweight backend options, and unified debugging. Discusses distribution methods, auto-updater with binary diffs, permissions, and sandboxing. Demo of a matrix client app, native UI integration, backend limitations, PWA support, rendering engine selection, and CSS features in Deno Desktop App.
Debugging Performance With AI
6 min
Debugging Performance With AI
The speaker discusses the challenges of debugging rendering performance and the potential of using AI to address this issue efficiently. Emphasizes the limitations of current tools in providing detailed insights into rendering performance compared to JavaScript performance. Highlights the laborious and repetitive nature of manual optimization processes in improving rendering speed and the role of AI in automating such tasks. Discussing the importance of AI in simplifying complex tasks and flattening the learning curve, particularly in debugging performance issues. Highlighting the significance of installing Chrome developer tools MCP for effective AI utilization. Introducing techniques such as regression bisection and standalone reproduction for efficient performance issue identification and resolution. Exploring synthetic stress tests as a technique to magnify performance issues for better visibility. Demonstrating the power of creating extreme scenarios, like a page with 100,000 divs, to identify and replicate complex problems. Emphasizing the extensive capabilities of AI in systematically troubleshooting and proactively identifying performance bottlenecks.
Black Friday: Would You Choose the Right Performance Test?
16 min
Black Friday: Would You Choose the Right Performance Test?
The talk discusses system failures in production despite passing tests, emphasizing the importance of spike testing during events like Black Friday. It highlights the consequences of not being prepared for sudden traffic spikes, such as errors, user dissatisfaction, and revenue loss. Common challenges in spike testing include thread pool saturation, database locks, and auto-scaling delays. Setting up a spike testing model involves identifying peak hours, establishing baselines, and creating realistic traffic distribution models to simulate scenarios like Black Friday.
Designing a Migration to Micro-Frontends
30 min
Designing a Migration to Micro-Frontends
In the last decade, Microfront Ends have seen widespread adoption in major companies, streamlining application development. Understanding Microfront Ends involves focusing on independence, fast flow, and migration goals over specific tools. Common architectures include application shell or UI composer and utilizing CDN for static files. Efficient deployment strategies include canary releases, edge computing, and rapid deployment frequency. Data sharing techniques include query strings, cookies, and event emitters for inter-microfrontend communication. Nurturing software growth and managing strategies for shared domain models and vendors are crucial for effective collaboration and development.
Software Craftless: Writing Code That Would Make a Goat Vomit
15 min
Software Craftless: Writing Code That Would Make a Goat Vomit
The talk delves into the concept of writing complex code to boost creativity and appear smarter, using JavaScript challenges to highlight the importance of front-end development. It suggests adding confusion to code, utilizing complex functions, and mixing library versions. The future of front-end development involves emoji CSS, diverse HTML tags, and functional CSS. Architectural design principles include over-engineering systems, using diagrams with circles and hexagons, and organizing code by type. Effective testing strategies focus on code coverage, unit testing, and test order. Optimizing UI design, AI usage, and ethical AI utilization are essential, alongside audience engagement for feedback and social media interaction.
A Leak in the Shell – How Refactoring Autocomplete Broke Us and How We Fixed It
26 min
A Leak in the Shell – How Refactoring Autocomplete Broke Us and How We Fixed It
Glad to talk about JavaScript and Mongosh, a database CLI for MongoDB. Wanted to enhance autocomplete. Challenges with out-of-memory errors during testing. Debugging involved reducing heap size and using Node.js flags for memory analysis. Understanding memory retention challenges in JavaScript. Fixing memory retention bugs in Node.js core REPL for improved memory management. Introducing Finalization Registry and V8.QueryObjects for observing object finalization in JavaScript. Utilizing HeapSnapshots for memory leak debugging and AI integration. Challenges in understanding and debugging applications. Gap in testing autocomplete release with feature flag variations. Reliable ways to flush GC before heap inspection using v8.get heap snapshot and Node.js flag.
Rustifying Vite: Designing a Hybrid Toolchain for the Real World
6 min
Rustifying Vite: Designing a Hybrid Toolchain for the Real World
The Talk explores JavaScript, TypeScript, Vite, and the move towards rolldown as a unified bundler. Rolldown combines the best features from previous tools, addressing challenges of multiple bundlers and complexity. It offers advanced chunking and a built-in minifier for optimized bundles. Integration of Rust-based bundles with JavaScript ecosystem through Swangular, filter functions, native Rust plug-ins, module resolution, TypeScript JSX transform, and toolchain V+ is discussed.
From Legacy to Delight: The Future of Node.js DX
21 min
From Legacy to Delight: The Future of Node.js DX
Claudio Bonder discusses the importance of Node.js documentation and the recent improvements made in developer experience. The evolution of Node.js API documentation has influenced tools and millions of users, with previous outdated tools leading to challenges in maintenance. The introduction of Dockit aimed to revolutionize Node.js API documentation with modern technologies. Dockit enhances documentation generation by supporting various sources, customization through AST and GSX transformation, and ensuring high-quality documentation for Node.js and community projects. The tool's innovative approach prioritizes user experience, collaboration, and strict common mark specification for efficient API doc creation.