Talks from our events
Latest
All talksThe Last Software Engineer
AI Coding Summit London
21 min
The Last Software Engineer

Kent C. Dodds introduces the concept of durable skills and the importance of physical movement. AI evolution involves fine-tuning, prompt engineering, and uncertainties. Reflecting on the future role of AI in work and the evolving technology landscape. Insights on product engineering emphasize judgment, hitting targets, and prioritizing target selection. The importance of user-centric product engineering, intentional decisions, and adapting skills in the agentic coding world are highlighted.
Tanstack Start and How It Supports React Server Components
React Summit 2026
27 min
Tanstack Start and How It Supports React Server Components

Introducing 10-Stack Dart, a full-stack framework for client-first applications, with server features and support for React and Solid. Discussion on the necessity of React server components and their role in providing data streams for React. Exploring handling server components in 10 sec start, server functions as the boundary for server-rendered UI, caching mechanisms, and flexibility in returning multiple server components. Managing route-based caching, multiple server components in one function, and using query cache for server-rendered UI. Deciding server composition, client-controlled structure, composite components for interactive UI elements, and ensuring type safety in composition models. Understanding the power and flexibility of server components in application architecture, migration from React router to 10-stack start, and challenges with release stability and usage of RSCs. Discussing the implementation of RSC in 10-stack start, its usage in new projects, differences with Next.js, and comparisons of one-way RSCs with Next.js.
Open Source Voice AI: How We Built ChatGPT's Voice Mode Infrastructure
JSNation 2026
20 min
Open Source Voice AI: How We Built ChatGPT's Voice Mode Infrastructure

Voice interaction with AI is evolving rapidly, focusing on creating natural conversation experiences with crucial time delays. Models in Voice AI are rapidly evolving, emphasizing the importance of latency budgets. Design decisions aim to minimize latency per stage, impacted significantly by network and backend location. Winning teams treat latency budgets like profit and loss statements, with user completion detection being crucial. Understanding VAD thresholds and turn detection importance to avoid frequent interruptions. Prioritizing interruption handling and efficient function calling for user engagement. Enhancing function call responsiveness and optimizing voice agent workflows for efficient task handling. Automated evaluations with LLM judge and observability prioritization for latency and audio replay. Development in Voice AI follows an iterative approach, starting narrow and expanding with an evaluation framework.
Building Bridges to a Post-SPA Future
React Summit 2026
33 min
Building Bridges to a Post-SPA Future

The speaker reflects on professionalism, tech collaboration deficiencies, and changing perspectives. They discuss React community involvement, cultural implications of technology choices, and the impact of Core Web Vitals on React sites. External factors like networks influence web development, optimizing JavaScript in browsers is crucial, and rethinking design based on user interactions is highlighted. Income influences smartphone market segmentation, Android pricing impacts the ecosystem, and adapting technology based on user data is essential. Transitioning to HTML-first in browser interfaces and user-centric testing to improve website quality are key takeaways.
What RSCs Can Do in Next.js Today
React Summit 2026
36 min
What RSCs Can Do in Next.js Today

Aurora discusses the journey of React Server Components in Next.js, emphasizing the importance of composability and scalability. The shift to server-side data fetching with enhanced composability and declarative nature is explored. The significance of self-contained components for fast server-side data fetching and improved user experience is highlighted. NextGIS app router is discussed for enhanced performance and optimized data caching. Version 16 introduces cache components for optimized data caching and instant navigations. Improvement in user experience with Next 16.3 through app shells, partial prefetching, and instant insights is emphasized. The talk also covers new components and features for server-side rendering, optimizing loading speed, animations, and playlist integration in Next.js.
University is My Side Hustle: How Gen Z Builders Ship to Production
React Summit 2026
15 min
University is My Side Hustle: How Gen Z Builders Ship to Production

Artemis, Canoparty founding engineer and university student in Computer Science, discusses the impact of AI on universities and how the younger generation adapts to the AI era. Gen Z builders embracing immediate deployment of AI tools for impactful production without traditional career progression. Young people now prioritize impact over traditional education paths, emphasizing hands-on learning in production and experimentation. Builders face challenges in transitioning personal projects to production but can leverage tools for startup creation. Engineers should emphasize simplicity in communication and the importance of selling the vision before building. Cloud Code simplifies setup for non-technical individuals. Interacting with real users and shipping features daily at Canoparty. Surround yourself with bold decision-makers and prioritize fast production.
This Component Could Have Been A Class
React Summit 2026
33 min
This Component Could Have Been A Class

Scott introduces React 3 Fiber, emphasizing its uniqueness and ease of use. Discussing the benefits of exploring web APIs beyond the React bubble for enhanced user experience. Exploring CSS properties for animations and scroll snap API for touch support. Leveraging browser capabilities for innovative user experiences. Highlighting advanced CSS techniques and new HTML features for UI design. AI integration in code efficiency and component building. Strategies for AI-written CSS and optimizing AI tools. Firefox's API prioritization and positive trends. Tailwind's role in modern CSS development and impact on React developers.
Streaming Systems, Hidden Risks, And AI-driven Consequences
AI Coding Summit London
27 min
Streaming Systems, Hidden Risks, And AI-driven Consequences

The Talk covers various aspects of deception and security in AI and data systems. It discusses the historical use of misinformation during World War II to influence decision-making. AI model poisoning through malicious data input and the challenges of ensuring data integrity in real-time pipelines are highlighted. The importance of peripheral information attacks, data contracts, stream governance, and anomaly detection in maintaining AI system security is emphasized. Strategies for protecting data integrity, detecting anomalies, and choosing appropriate AI models are also discussed.
Rustifying Vite: Designing a Hybrid Toolchain for the Real World
JSNation 2026
6 min
Rustifying Vite: Designing a Hybrid Toolchain for the Real World

Options for pre-bundling, transformation, and minification. Rollup, bundling, and limited chunk control. SWC for React, but complexity with multiple bundlers causing issues for maintainers and developers. Limitations in bundlers, features V8 needs. Improving build times with Rust. Introducing Roldown with rollup's API, compatibility, speed, and advanced chunking. Features like module types, lazy barrel optimization, HMR, and built-in minifier for a performant bundle. Ensuring Rust-based bundler compatibility with JavaScript ecosystem. Introduction of Swangular for efficient plugin handling. Native Rust plugins support with module resolution, aliases, TypeScript JSX transform, dynamic imports. Integration with underlying minifier, transformer, linter, and formatter for tool chain V+.
Panel Discussion: Fullstack is Eating Frontend — Should FE Engineers Adapt?
React Summit 2026






35 min
Panel Discussion: Fullstack is Eating Frontend — Should FE Engineers Adapt?







6 authors
Full stack vs. frontend specialization debate. Importance of understanding the full system for developers. Analogy of developers being like doctors knowing the whole system but specializing in certain areas. Specialization in the age of AI. Importance of specialists in the era of quick generalization with AI. The value of being a frontend developer post-AI, emphasizing the importance of specialization and knowing how to guide AI in specific areas. Specialization in Frontend Development and the Evolution of Frameworks. Importance of specialized frontend development skills in the modern age. The shift towards empowering app developers to handle database setup and configuration. The evolution of frontend frameworks to abstract complex tasks and empower developers to manage caching and CDNs. AI reliance on good documentation for effective performance. The importance of human guidance and interaction in maximizing AI capabilities across development specialties. AI as a complementary tool, not a substitute. Understanding the importance of skill set integration with AI technologies for effective outcomes. Frontend engineers must embrace continuous learning and understanding AI's first principles. Embracing curiosity and adapting to rapid technological changes for professional growth and development. Discovering the limitations of specific knowledge transfer and the importance of fundamental skills over tool-specific expertise. Embracing a patient approach to adopting new technologies and focusing on learning essential skills for AI without chasing every new tool or trend. Exploration of using agents for self-learning workflows, preparing for questions through Q&A sessions, and elevating thinking by utilizing tools effectively. Importance of motivated learning, questioning, and utilizing agents effectively in the learning process, recognizing significant technological advancements, and the value of independent learning over solely relying on agents.
Featured
Agentic Interfaces: Tools, Skills, Generative UI and Web MCP
JSNation 2026
31 min
Agentic Interfaces: Tools, Skills, Generative UI and Web MCP

Wes discusses the evolving ways of interacting with software, from UI to voice commands and tailored interfaces. He explores generative UI, explaining its three levels: basic, declarative, and fully generative. Discussions on finding a middle ground between known components and fully generative approaches. Discussing challenges with current MCP interfaces and the need for adaptive and reactive interfaces, using smart home examples to illustrate preferences for UI interactions and personalized automation. Exploring the versatility of WebMCP in switching between manual and agent-controlled interactions for enhanced user experiences. Discussing staying hopeful in front-end development, embracing new technologies, and the concept of dynamic UI for user-driven component selection. Discussing the importance of preserving the openness of the web, advocating against centralized control by a few companies, and the risks associated with MCPs in user consent and security.
npm install && pray
Node Congress 2026
29 min
npm install && pray

JavaScript developers face security risks in npm packages with self-replicating worms compromising packages. Supply chain attacks target prolific maintainers leading to unauthorized code injections. Vulnerabilities in package maintainers and implicit trust contribute to successful attacks. Secure package installation practices vary between npm and Deno. AI-generated code introduces new security risks with embedded secrets. Secure AI code execution involves sandboxing for isolation and secure handling of API keys.
No REST for Cap'n Web
Node Congress 2026
23 min
No REST for Cap'n Web
Top Content

Kenton Varda advocates for using CapnWeb, an RPC protocol, over REST for web APIs, emphasizing benefits for humans and AI agents. CapnWeb simplifies client-server communications by treating them as function calls. TypeScript type checking ensures method accuracy in CapnWeb across JavaScript runtimes. Stubs in CapnWeb allow method calls to execute on remote objects and simulate all possible method names for remote calls. Converting REST APIs to CapnWeb streamlines code and improves API calls. CapnWeb enhances API functionality with object-specific RPC sessions and promises pipelining for multilevel API optimization. AI agent security challenges are addressed with sandboxing and token protection in CapnWeb. CapnWeb capabilities for AI agents include passing restricted CapnWeb stubs and exploring capability-based security with CapnProto.
Every API is a Tool for Agents with Code Mode
Node Congress 2026
32 min
Every API is a Tool for Agents with Code Mode

The Talk introduces APIs, Codemode, and MCP, highlighting the role of APIs in empowering agents and AI's access to external resources. CloudFlare's evolution with MCP involves remote tool sharing and addressing challenges like large context windows. Challenges in Cloudflare's API tool access include progressive tool disclosure and splitting MCP servers. The discussion covers tool search, project management API creation, CodeMode concept, and self-documenting tools for secure tool execution. Proposed solutions include Code Mode, SDK generation, efficient control flow, token efficiency, and secure code execution. Key topics include dynamic worker loaders, Cloudflare API integration, Visitor Counter implementation, and exploring MCP server functionality.
We Deserve a Better Streams API for the Web
Node Congress 2026
30 min
We Deserve a Better Streams API for the Web

James Snell discusses challenges in current stream APIs, proposes a new, faster, and simpler streams API while questioning the existing Web Streams model. Discussion includes the necessity for a new API due to excessive ceremony, confusing locking mechanisms, and complex specifications, especially in controller APIs. Challenges with controller API optimization, hidden buffering, and excessive memory usage are highlighted. The talk delves into the cost and complexity of promises in JavaScript, optimizing readable streams, and managing complexity in stream implementations. Optimizing stream processing in JavaScript, data chunk processing, back pressure policies, multi-consumer patterns, and efficient branch cursor management are explored. The new API aims at simplifying stream processing by eliminating unnecessary operations, reducing promise overhead, and focusing on iterators, transforms, and back pressure for efficiency and simplified design.
The New AI Workflows
React Advanced 2025
14 min
The New AI Workflows

The Talk delves into the impact of LLMs on engineering workflows, emphasizing the shift towards AI for code writing efficiency. It highlights the importance of problem-solving abilities and product development in hiring practices. LLMs enhance productivity for developers, designers, and product managers, enabling faster iterations and collaboration. Efficient product workflows are achieved through simultaneous UI and code work using Builder.io. Task delegation is streamlined with async agents and Builder bots, optimizing project editing and code management. Integration with tools like VS Code and Figma streamlines design and code editing, enhancing collaboration and workflow automation.
From Segments to Suspense: The Future of Next.js Caching
React Advanced 2025
27 min
From Segments to Suspense: The Future of Next.js Caching

Introduction to Cache Components in Next.js 16, transforming the app router with new features like partial pre-rendering, Dynamic I.O., and caching directives. Deep dive into static params generation in Next.js focusing on changes in generating static params for improved performance. Exploring challenges of generating static params and balancing static vs. dynamic rendering for better performance. Addressing challenges with cache components, optimizing static and dynamic rendering for improved performance. Understanding impact of parameters on rendering with cache components, managing dynamic components, and introducing suspense boundaries for faster page loads. Enhancing cache life APIs, introducing a new caching model for static outputs in Next.js. Revolutionizing cache management with granular control over cache lifetimes and dynamic segment configuration. Navigating data and caching in Next.js, exploring cache components guidance and caching differences between server and client components.
Keeping Up with The Fast and Furious Web
JSNation US 2025
29 min
Keeping Up with The Fast and Furious Web

Scott Talinsky's journey in web development highlights his transition from YouTube tutorials to creating educational content and courses, reflecting his passion for teaching. The evolution of web development tools showcases advancements from limited colors to modern frameworks like React and CSS features like squircles. Adapting to new technologies emphasizes core skills and freedom in tool selection. User-centric development prioritizes accessibility and understanding the purpose of tools. Learning strategies focus on fundamentals, hands-on learning, and avoiding influencer bias. Standing out in tech roles requires quality projects, broad knowledge, and effective communication.
The Dark Side of Micro-Frontends
React Advanced 2025
29 min
The Dark Side of Micro-Frontends

In the Talk, various key points were discussed regarding micro-front-end architecture. These included challenges with micro-intents, common mistakes in system design, the differences between micro-intents and components, granularity in software architecture, optimizing micro-front-end architecture, efficient routing and deployment strategies, edge computing strategies, global state and data sharing optimization, managing data context, governance and fitness functions, architectural testing, adaptive growth, value of micro-frontends, repository selection, repo structures, and web component usage.
The AI-Native Software Engineer
JSNation US 2025
35 min
The AI-Native Software Engineer
Top Content

Software engineering is evolving with AI and VIBE coding reshaping work, emphasizing collaboration and embracing AI. The future roadmap includes transitioning from augmented to AI-first and eventually AI-native developer experiences. AI integration in coding practices shapes a collaborative future, with tools evolving for startups and enterprises. AI tools aid in design, coding, and testing, offering varied assistance. Context relevance, spec-driven development, human review, and AI implementation challenges are key focus areas. AI boosts productivity but faces verification challenges, necessitating human oversight. The impact of AI on code reviews, talent development, and problem-solving evolution in coding practices is significant.
Trending today
The Future Stack of Code Review
JSNation 2023
22 min
The Future Stack of Code Review

The Talk discusses the challenges of code reviews and the need to redefine the code review process in light of changes in software development. It emphasizes the importance of collaboration, security, performance, and clean code in the new stack of code review. The Talk also highlights the benefits of automating code review comments and optimizing the code review process. Overall, the Talk aims to build a better code review process that promotes collaboration and improves the quality of software development.
Mess to Modern: Refactoring a React Nightmare
React Summit 2026
18 min
Mess to Modern: Refactoring a React Nightmare

Have you ever faced complex and messy React codebases? Caleb Garner shares a five-step playbook to transform a 900-line React component. Addressing systematic modularity and organization structure for better code management. Enhancing codebase structure by extracting business logic for testability and maintainability. Streamlining state and data management for robust codebases. Establishing predictable data handling with userReducer for structured state management. Optimizing component modularity for reusability and efficient data management. Emphasizing caller-controlled layout and streamlined development experience through five key principles.
Orchestrating Content Workflows at Netflix Scale
Web Engineering Summit 2026
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.
CLI, GUI, or Just Blind Trust? A Tour of Code Review Styles
React Summit 2026
6 min
CLI, GUI, or Just Blind Trust? A Tour of Code Review Styles

Introduction to traditional code review methods and challenges faced by developers. Challenges with code review process and the shift towards AI era and CLI-based reviews. Using IDEs for code review, agentic era support, and enhancing code view for human-agent collaboration. New CodeRabbit view for code analysis, free for open source projects, support for old school and agentic engineers.
Network Requests with Cypress
TestJS Summit 2021
33 min
Network Requests with Cypress
Top Content

Cecilia Martinez, a technical account manager at Cypress, discusses network requests in Cypress and demonstrates commands like cydot request and SCI.INTERCEPT. She also explains dynamic matching and aliasing, network stubbing, and the pros and cons of using real server responses versus stubbing. The talk covers logging request responses, testing front-end and backend API, handling list length and DOM traversal, lazy loading, and provides resources for beginners to learn Cypress.
A Brief History of Code Review (And What's Next)
JSNation 2026
8 min
A Brief History of Code Review (And What's Next)

The Talk explores the transition from solo development to code review history, tracing it back to the Fagin Inspection process in the 1990s. It discusses the evolution of code collaboration from in-person meetings to remote, email-based discussions. The shift to modern code review via pull requests on GitHub improved collaboration efficiency. The integration of AI in code review enhanced processes and enabled instant feedback. Encouraging open source projects to adopt code review tools and prioritize the importance of thorough reviews is highlighted.
Nested Interactive Elements: An Nightmare in Accessibility
React Advanced 2023
23 min
Nested Interactive Elements: An Nightmare in Accessibility
Top Content

Nested interactive elements can cause accessibility issues on websites, and the speaker shares a personal experience with an accessibility bug involving a list component. Mitigating nested interactive structures involves limiting these patterns during development and restructuring existing elements. The speaker provides recommendations for improving accessibility, such as adjusting role properties and gathering user feedback. The conclusion emphasizes the importance of accessible solutions and encourages sharing resources to build more inclusive experiences.
Chunking
JSNation 2026
28 min
Chunking

Tobias Koppers explains chunking in Bundlers, emphasizing efficient module grouping for performance optimization. Strategies involve smart module grouping, caching, and balancing between request counts and download sizes. CSS delivery via link tags poses complexity in chunking due to order dependencies. Balancing CSS chunking to reduce requests involves overshipping techniques. Evolving chunking strategies consider compile time challenges and the impact of React server components. Future optimizations may prioritize pages based on analytics data. Tailwind offers a solution for CSS chunking, while the need for future CSS features with native dependency declarations is highlighted.
We Need More Than Prompts
React Summit 2026
28 min
We Need More Than Prompts

Alex discusses spec-driven development as the best approach for building software with AI, emphasizing the importance of planning ahead and tools evolution. Reflecting on coding tools evolution towards instructing AI agents and changing roles. Challenges in articulating coding intent and the need for Spec-Driven Development. Importance of changes, goals, and OpenSpec in development. Up-front planning, collaborative nature, and challenges in spec-driven development highlighted. Managing AI limitations, spec updates, and collaborating with non-engineering on specs. Optimizing prompts and spec organization, context importance, and OpenSpec skills.
The Last Software Engineer
AI Coding Summit London
21 min
The Last Software Engineer

Kent C. Dodds introduces the concept of durable skills and the importance of physical movement. AI evolution involves fine-tuning, prompt engineering, and uncertainties. Reflecting on the future role of AI in work and the evolving technology landscape. Insights on product engineering emphasize judgment, hitting targets, and prioritizing target selection. The importance of user-centric product engineering, intentional decisions, and adapting skills in the agentic coding world are highlighted.
Short takes
Everyone Is Now a Manager - Interfaces in the World of Agents
TechLead Conf London 2025: Adopting AI in Orgs Edition
6 min
Everyone Is Now a Manager - Interfaces in the World of Agents

Sam Kmezverk's talk covers the evolving tech landscape, emphasizing key principles for agents' implementation in tasks and decision-making processes. Addressing challenges in agent orchestration, debugging system issues, and cultivating user trust are crucial for successful interface development.
Ensuring Quality with AI
TechLead Conf Amsterdam 2026: Adopting AI in Orgs Edition
7 min
Ensuring Quality with AI

Richard Rodenkemper, senior software engineer at Sentry, discusses ensuring quality with AI. GitHub data shows exponential growth in coding. Concerns arise about the reliability of coding agents versus human engineers. Impact of AI and Cloud on code production and app quality is questioned. Challenges in code reliability despite increased production are highlighted. AI as a quality tool in software development. Importance of reliability for product success highlighted. AI's strengths in handling data and searching code base discussed. Examples of AI usage in code reviews and quality assurance at Sentry shared. AI efficiency in endpoint deprecation and system updates highlighted. AI's assistance in migrating design systems and reducing notifications using Cloud Code emphasized.
Optimizing the Path From Design to Production in Engineering Workflows
React Summit US 2025
7 min
Optimizing the Path From Design to Production in Engineering Workflows

Akbar, developer advocate at Figma, highlights the importance of exploration, representation, and production in product development. Figma leverages design systems and AI tools for efficient transition from representation to production, optimizing expertise and automating non-critical tasks. Seamless integration between design elements and the app is achieved through tools like Code Connect and Copilot, fostering collaboration between design and code.
Shipping AI Under Constraints: Build, Buy, or Kill
TechLead Conf London 2025: Adopting AI in Orgs Edition
8 min
Shipping AI Under Constraints: Build, Buy, or Kill

Dave, Engineering Manager at Capital Untap, shares a story of AI failure and lessons learned from moving too fast in AI development within the company. The AI team focused on developing a chatbot for customer service, which became a flagship initiative under engineering governance. Issues with accuracy and complexity led to pausing the chatbot project and exploring third-party vendors. Capital OnTap reset AI processes by integrating AI engineers into product teams, emphasizing standard engineering over specialized AI teams.
Framework Native Rendering Without Code Duplication?
React Summit 2026
6 min
Framework Native Rendering Without Code Duplication?

Talking about an experiment in Agigrid to render to multiple frameworks without duplicating code. Exploring MVC approach for structuring code base and handling view complexity efficiently. Exploring new ways to structure view logic and render components efficiently across frameworks within Agic Grid experiment.
Deploy Your AI Code in Minutes
AI Coding Summit 2026
7 min
Deploy Your AI Code in Minutes

Shifra guides the migration of a Repl.it app to Render with emphasis on simplicity and mock data. Ensure Render deployment requirements are met, including specifying root directory, build and start commands, and correct port. Configure GitHub repository setup, connect to Git, and create a repository. Confirm code in the repository and deploy on Render, showcasing a sample landing page.
Navigating Islands of Interactivity
React Advanced 2025
9 min
Navigating Islands of Interactivity

Islands in web development are interactive components that are rendered on the server and hydrated separately. They offer fine-grain control over JavaScript, speed up page loading, and reduce JavaScript shipping. Applications of islands span across eCommerce, media sites, docs, and blogs, providing interactivity without excessive JavaScript. Nanostores enable state sharing among islands. Key takeaways include utilizing Nanostores for state management, exploring ASTRO and islands for development, and using client directives for JavaScript control.
CLI, GUI, or Just Blind Trust? A Tour of Code Review Styles
React Summit 2026
6 min
CLI, GUI, or Just Blind Trust? A Tour of Code Review Styles

Introduction to traditional code review methods and challenges faced by developers. Challenges with code review process and the shift towards AI era and CLI-based reviews. Using IDEs for code review, agentic era support, and enhancing code view for human-agent collaboration. New CodeRabbit view for code analysis, free for open source projects, support for old school and agentic engineers.
Taming the Flicker: Firebase Patterns for React Server Components
React Summit 2026
7 min
Taming the Flicker: Firebase Patterns for React Server Components

Rosario from Firebase highlights challenges of client-side development and Firebase solutions like server app for authentication. Firestore's offline cache and real-time updates improve user experience. Updating UI to prevent authentication flickers and optimizing real-time components with onSnapshotResume and feature flagging. Introducing Firebase App Hosting and SQL Connect for server-side rendering and SQL database integration, with upcoming Crashlytics for web.
Rustifying Vite: Designing a Hybrid Toolchain for the Real World
Web Engineering Summit 2026
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.
Popular
Yarn 4 - Modern Package Management
JSNation 2022
28 min
Yarn 4 - Modern Package Management
Top Content

Yarn is a package manager that focuses on stability, performance, and security. It offers unique features like plug and play installation, support for nonmodules, and the exec protocol. Yarn is committed to being a good citizen in the open-source community and contributes to fixing dependencies. It is part of the Node.js Loader's working group and advocates for Corepack. Yarn is still experimental but is improving its user experience and security features. Contributions are welcome, and switching to Yarn can improve performance in large projects.
Welcome to Nuxt 3
Vue.js London Live 2021
29 min
Welcome to Nuxt 3
Top Content

Nux3 has made significant improvements in performance, output optimization, and serverless support. Nuxt Bridge brings the Nitro engine for enhanced performance and easier transition between Nuxt 2 and Nuxt Read. Nuxt 3 supports Webpack 5, Bytes, and Vue 3. NextLab has developed brand new websites using Docus technology. Nuxt.js is recommended for building apps faster and simpler, and Nuxt 2 should be used before migrating to Nuxt 3 for stability. DOCUS is a new project that combines Nuxt with additional features like content modules and an admin panel.
Multithreaded Logging with Pino
JSNation Live 2021
19 min
Multithreaded Logging with Pino
Top Content

Today's Talk is about logging with Pino, one of the fastest loggers for Node.js. Pino's speed and performance are achieved by avoiding expensive logging and optimizing event loop processing. It offers advanced features like async mode and distributed logging. The use of Worker Threads and Threadstream allows for efficient data processing. Pino.Transport enables log processing in a worker thread with various options for log destinations. The Talk concludes with a demonstration of logging output and an invitation to reach out for job opportunities.
Domain Driven Design with Vue Applications
Vue.js London 2023
14 min
Domain Driven Design with Vue Applications
Top Content

Welcome to this talk on domain-driven design in Vue.js application. Today we are going to look into domain-driven design, its benefits and how it works with Vue.js domain-driven design versus the MVVM model. Vue.js thrives in domain-driven design, a design approach that models software to match a domain. DDD emphasizes understanding business logic and creating a domain that reflects the language and concepts. Integrating DDD in Vue.js offers benefits such as effective modeling of complex business domains, structured code reflecting domain logic, and easier onboarding and ownership.
TypeScript and React: Secrets of a Happy Marriage
React Advanced 2022
21 min
TypeScript and React: Secrets of a Happy Marriage
Top Content

React and TypeScript have a strong relationship, with TypeScript offering benefits like better type checking and contract enforcement. Failing early and failing hard is important in software development to catch errors and debug effectively. TypeScript provides early detection of errors and ensures data accuracy in components and hooks. It offers superior type safety but can become complex as the codebase grows. Using union types in props can resolve errors and address dependencies. Dynamic communication and type contracts can be achieved through generics. Understanding React's built-in types and hooks like useState and useRef is crucial for leveraging their functionality.
Draft.js, Editor.js, Slate.js: Choosing the Best Text Editor for Your React Project
React Summit Remote Edition 2021
8 min
Draft.js, Editor.js, Slate.js: Choosing the Best Text Editor for Your React Project
Top Content

Welcome to my session on DraftJS, EditJS, and SlideJS. We will discuss their strengths and data model, focusing on React's component and prop model. We will evaluate the editors based on their sustainability, funding, support, maturity, license, editor features, release cycle, data structure, ecosystem, browser support, usage, and GitHub stars. The first editor we'll discuss is Draft.js, which is used by Facebook Messenger, comments, status posts, and the Facebook Notes app. It's funded and supported by Facebook, has a version of 0.11.7, and requires custom code for additional features. The license is MIT. It's a bare metal, in terms of features. The release cycle is semantic version. The data structure is JSON. It's used by 83,000 packages and has 20,000 stars. The data model is made up of blocks with text and entities. It supports various editor features including block styles, inline styles, undo/redo, paste, lists, nested lists, media, and links. Editor.js is a block-based editor written in vanilla JavaScript. It has a 2.19 release, Apache 2.0 license, and a semver release cycle. The data structure is JSON, and there are numerous plugins available. It has 1,500 packages using it and 15,000 stars. The editor features include block styles, inline styles, undo/redo, paste, lists, nested blocks, media, and links.
AWS Lambda under the hood
Node Congress 2023
22 min
AWS Lambda under the hood
Top Content

In this Talk, key characteristics of AWS Lambda functions are covered, including service architecture, composition, and optimization of Node.js code. The two operational models of Lambda, asynchronous and synchronous invocation, are explained, highlighting the scalability and availability of the service. The features of Lambda functions, such as retries and event source mapping, are discussed, along with the micro VM lifecycle and the three stages of a Lambda function. Code optimization techniques, including reducing bundle size and using caching options, are explained, and tools like webpack and Lambda Power Tuning are recommended for optimization. Overall, Lambda is a powerful service for handling scalability and traffic spikes while enabling developers to focus on business logic.
Using MediaPipe to Create Cross Platform Machine Learning Applications with React
React Advanced 2021
21 min
Using MediaPipe to Create Cross Platform Machine Learning Applications with React
Top Content

MediaPipe is a cross-platform framework that helps build perception pipelines using machine learning models. It offers ready-to-use solutions for various applications, such as selfie segmentation, face mesh, object detection, hand tracking, and more. MediaPipe can be integrated with React using NPM modules provided by the MediaPipe team. The demonstration showcases the implementation of face mesh and selfie segmentation solutions. MediaPipe enables the creation of amazing applications without needing to understand the underlying computer vision or machine learning processes.
React Query - The Bad Parts
React Day Berlin 2024
30 min
React Query - The Bad Parts
Top Content

React Query is a popular library with significant weekly downloads and positive user sentiment. It may have trade-offs like bundle size, but the actual size shipped is smaller. Bundle size optimization can be achieved by exporting only necessary features. React Query's declarative approach eliminates the need for custom data fetching solutions. It offers caching, request duplication, background updates, and more. RackQuery doesn't support normalized caching, but refetching after invalidation works fine. React's vision includes suspense architecture and server components. The documentation could be improved with a more structured flow. TensorStack Query can be a good choice for Next.js apps, but not necessary with mature frameworks. The 10 stack query and router concepts were discussed. Combining React Query with HTTP caching provides a robust caching solution.
Building a JS Engine -- For Fun!
JSNation 2024
9 min
Building a JS Engine -- For Fun!
Top Content

The Talk discusses the basics of building a JS engine, highlighting the complexity and feature completeness of existing engines. It emphasizes the possibility of creating a simpler engine tailored to specific use cases and target audiences. The speaker suggests starting anywhere in the process and provides tips on using parser libraries, implementing runtime features, and ensuring correctness through testing. Additionally, the Talk encourages exploring JavaScript standards and engaging with the open-source community.
React
Replacing Form Libraries With Native Web APIs
React Summit 2026
17 min
Replacing Form Libraries With Native Web APIs

Jamin discusses the shift from using form libraries to native web APIs in React development, emphasizing the benefits of exploring web-native APIs before relying on libraries. The talk covers topics such as Constraint Validation API, React 19 form actions, and CSS pseudo-classes for form building without libraries. It highlights real-time validation, simplified form submission, and custom error handling in React forms. The importance of customizing error messages, setting up custom error handling, and optimizing form performance are also addressed, along with challenges and recommendations for utilizing web native APIs in form development.
Giving AI Agents Hands: Mobile Feedback Loops with Agent Device
React Summit 2026
26 min
Giving AI Agents Hands: Mobile Feedback Loops with Agent Device

The speaker discusses the evolution of AI agent workflow in mobile development, emphasizing the importance of feedback loops and verification. They highlight the challenges of human involvement as agents dominate code production. Agent Device simplifies mobile automation by focusing on accessibility trees and text-based actions. The tool enhances app verification, debugging capabilities, and provides advanced features like network issue identification. Agent Device is versatile for CI setup, feedback loops, and visual regression detection. It supports real devices and offers capabilities for migrations and automation. Additionally, the speaker compares flakiness and TV platform support, showcasing performance improvements over traditional tools.
Mess to Modern: Refactoring a React Nightmare
React Summit 2026
18 min
Mess to Modern: Refactoring a React Nightmare

Have you ever faced complex and messy React codebases? Caleb Garner shares a five-step playbook to transform a 900-line React component. Addressing systematic modularity and organization structure for better code management. Enhancing codebase structure by extracting business logic for testability and maintainability. Streamlining state and data management for robust codebases. Establishing predictable data handling with userReducer for structured state management. Optimizing component modularity for reusability and efficient data management. Emphasizing caller-controlled layout and streamlined development experience through five key principles.
Lessons From Adopting React Compiler
React Summit US 2025
23 min
Lessons From Adopting React Compiler

Akash Hamilwasia presenting at React Summit 2025, shares React Compiler learnings and works on an AI audio platform. Memoization in React helps optimize UI performance by preventing unnecessary re-renders. React Compiler offers automatic memoization through static code analysis. React rules emphasize purity and immutability. The compiler analyzes and memoizes code changes for optimization. React Compiler package usage improves performance through code analysis. Understanding reactivity issues is crucial for handling React state. Compiler optimization requires correct dependency arrays and usage of external libraries. Measure React Compiler impact using React Profiler for optimization and real user impact analysis.
Modernizing Your React App: Compiler, useEffectEvent, Activity & Friends
React Summit 2026
27 min
Modernizing Your React App: Compiler, useEffectEvent, Activity & Friends

Victor shares experiences inheriting codebase and explains the importance of React's updates for code cleanliness. Agenda includes React evolution, API usage, modernization playbook, and insightful discussions. React 19 impact on React's evolution towards a declarative model for state management and form handling. React's shift towards a declarative model, impacting form handling and state management with React 19 updates, including new APIs and the importance of the React compiler for efficient development. Using React compiler for efficient development and code simplification. Measuring code base changes with memorization hooks identification. Introducing user fact event API for dependency-free code. Handling state persistence challenges with the Activity API for seamless user experiences and resource management. Utilizing the Activity API for precise state management and resource optimization in React Native applications. Exploring powerful user cases: tabs example, pre-rendering, and back navigation benefits with the Activity API. Exploring the value of instant experiences with back navigation and code optimization through API adoption. Measuring success, avoiding AI dependence, and understanding the importance of learning for effective development. Addressing challenges post-AI era, emphasizing responsibility in learning, maintaining control, and ensuring security. Practical steps include using React compiler, auditing code for Activity API integration, and optimizing data flow for enhanced user experience.
Scaling React: What Actually Matters
React Summit 2026
30 min
Scaling React: What Actually Matters

Tathagath discusses the misconception of React's role in app slowness and emphasizes architecture over React performance. Context impact on app rendering is explored, along with React compiler enhancements. Global state misuse and state management in React are addressed. Performance pitfalls, optimizing app performance, and the impact of third-party scripts on React are discussed. Strategic management of third-party scripts and common mistakes in SSR applications are highlighted. Recognizing hydration costs and architectural impacts in React, as well as shifting mindset for performance optimization, are key points.
React Bits: The Art of Standout UI
React Summit 2026
21 min
React Bits: The Art of Standout UI

David, creator of React Bits, shares insights on designing standout UI components, emphasizing the importance of distinct interfaces without being noisy. ReactVids focuses on creating reusable visual moments for developers, ensuring standout UI accessibility. Community-driven evolution of React Bits prioritizes customization, usability, and key UI qualities. Magic Rings exemplifies the balance and purpose needed in UI components. The versatility of Magic Rings showcases the importance of a flexible visual system. Exploring shaders enhances the control and visual richness of Magic Rings. Leveraging shader uniforms enables dynamic visual effects in React components. Real creative controls in component design emphasize meaningful customization. Strategic props play a crucial role in reusable creative component development. The philosophy of React Bits focuses on easy adoption, customization, and providing a strong starting point for distinct interfaces. ReactVids aims to create memorable, intentional, and unique user moments in UI design.
React Strict Dom: Cross-Platform React Based on the Web
React Summit US 2025
29 min
React Strict Dom: Cross-Platform React Based on the Web

Talk on cross-platform React using ReactStrict DOM to unify web and native React, standardizing for consistent UI development. Fragmentation challenges in React due to lack of standardized styling systems, impacting development efficiency and product consistency. Exploring unsuccessful cross-platform React approaches and the importance of minimizing migration costs. Enabling web developers to build native apps with React Native while enhancing it with web APIs for seamless code migration. Benefits of code sharing for cross-platform apps, AI integration for React Strict DOM, and the future vision for React Native as a web renderer. Unified styling in React Native, Tailwind integration, and UI best practices. Flexibility and readiness in React DOM, potential inclusion in React Foundations, and considerations for reversibility of decisions in React DOM.
React Beyond the DOM
React Summit US 2025
27 min
React Beyond the DOM

Eric Rasmussen discusses React beyond the DOM, React PDF, Ink tools, and rendering to Markdown. The overview includes React Reconciler, host configuration, state management with real-world entities like light bulbs, and building a traffic light state machine visually. The talk also covers securing third-party JavaScript, expanding React rendering possibilities, advanced tooling for state machines, controlling light bulbs via renderer callbacks, server functions for fetch in the cloud, and potential robot programming with React.
Gotta Go Fast: React at 60 FPS
React Summit 2026
16 min
Gotta Go Fast: React at 60 FPS

Rachel Kaufman discusses animating in React without libraries for high performance. Client project for the International Spy Museum involved facial recognition education using React. React's unconventional use for complex UI animation in museum exhibits. Optimizing animation performance in React with request animation frame and using canvas for drawing. Managing continuous animations in React for smooth transitions. Leveraging canvas and refs for drawing and direct DOM access in React. Implementing complex animations with refs and request animation frame in React. Using memo and request animation frame for preventing unnecessary re-renders. Automating React debugging with Chrome DevTools and performance analysis with console.time.
Node.js
Breaking the Context Ceiling: Implementing Recursive Language Models with LangGraph and TypeScript
Node Congress 2026
21 min
Breaking the Context Ceiling: Implementing Recursive Language Models with LangGraph and TypeScript

Jamal Legaro discusses challenges with context windows in language models and recursive language models as a solution. Enhancing language model performance through metadata and summaries, orchestrator copies, and comparing scaffold and RLM approaches. Efficient management of language model operations with slicing, recursion, code execution, and context window handling. Graph-based workflow design in Langchain for agent connections and state management. Workflow management, document analysis, and using RLM for processing large documents. Detailed workflow setup, code structure with Langsmith, and node definitions with RLM benefits for cost considerations and production readiness.
Unlocking the Power of the Dependency Graph
Node Congress 2026
19 min
Unlocking the Power of the Dependency Graph

Rui Adorno emphasizes the power of dependency graphs in JavaScript projects, highlighting the underutilized graph structure and the importance of understanding metadata. The discussion delves into advanced dependency selector syntax, integrating query language with VLT client for updates and additions, running tests, and updating versions. The exploration of VLT client features includes secure package installs, phased installation processes, and DSS capabilities. Multi-project package filtering is expanded through DSS query language with a host local selector for benefits like script inspection and AI agents.
JavaScript File Handling Like a Pro: From ZIP Streams to Memory-Efficient Parsing
JSNation US 2025
24 min
JavaScript File Handling Like a Pro: From ZIP Streams to Memory-Efficient Parsing

Node.js offers significant capabilities for efficient file handling, emphasizing the importance of processing files effectively to avoid crashes and memory issues. Understanding streams, backpressure, and stream concepts like readable, writable, duplex, and transform streams is crucial for efficient file handling. Streams enable working with data in chunks, ensuring stable memory usage and efficient applications. Backpressure in streams optimizes memory usage by processing data incrementally, unlike loading entire files into memory. Utilizing readable streams in processing improves concurrency and avoids blocking the event loop.
Node.js + TypeScript: A Native Integration Years in the Making
JSNation US 2025
19 min
Node.js + TypeScript: A Native Integration Years in the Making

Welcome to JS Nation. Marco Ippolito discusses NodeJS and TypeScript integration, challenges, and growth. TypeStripping in Node.js removes TypeScript syntax for execution. Efficient TypeStripping in Node 22 skips SourceMaps, aligns with TypeScript versions. Enhanced features in Node 22 support experimental TypeScript features with limitations. Node.js supports TypeScript features with erasable syntax and namespace in Node 23.8. Importing types correctly crucial to avoid errors. Node.js TypeScript integration update includes switching to TypeScript, browser support, and community involvement.
Why Node.js Needs an Application Server
Node Congress 2026
18 min
Why Node.js Needs an Application Server

Matteo Collina discusses Node.js, its single-threaded design, and the introduction of threads in 2018 for parallelism and CPU utilization. Node.js production monitoring focuses on application health, fault tolerance, and event loop efficiency. VAT architecture improves Node.js applications with thread migration and monitoring. Node.js manages threads and failures independently with Prometheus monitoring. Scalability in Node.js involves Kubernetes clusters and in-process scaling. Next.js with React SSR for Node.js applications enables dynamic scaling and performance. Node.js handles CPU blocking and SSR performance by utilizing multiple threads.
The State of Node.js 2025
JSNation US 2025
19 min
The State of Node.js 2025

Matteo Collina presents an updated talk on Node.js, discussing roles, open-source projects, and dispelling myths. He highlights Node.js vitality, contrasts with legacy technologies like COBOL and jQuery. The talk covers Node.js popularity, software reuse, module growth, and download stats. It addresses risks of not updating Node.js, LTS support phases, version updates, adoption rates, security measures, Node 24 features like ESM support and stable permissions. Collaboration processes, TSC role, governance, and benefits of Platformatic VAT for app development are also discussed.
From Legacy to Delight: The Future of Node.js DX
JSNation 2026
21 min
From Legacy to Delight: The Future of Node.js DX

Claudio Bunder emphasizes the importance of Node.js documentation, highlighting its impact on the ecosystem and the challenges in maintaining it. Node.js API documentation tooling faces significant design and implementation hurdles, with a lack of documentation hindering user interaction. The transformation of Node.js API documentation was driven by the need to improve user experience. Dockit, an AST engine, streamlines API documentation generation with support for Markdown, JS Doc, and TS Doc, offering modular flexibility and community-driven documentation creation. Dockit's efficient processing of document structures and metadata, combined with a generator system, ensures high performance and scalability in API documentation generation.
The State of Node.js Security
Node Congress 2026
27 min
The State of Node.js Security

Introducing Node.js security overview, defining vulnerabilities, non-vulnerabilities, and preventive measures. Discussing Node.js API input validation, real vulnerabilities like HTTP server crashes, and the importance of Node.js security in widely used platforms. Discussing the importance of Node.js maintenance, the introduction of experimental permissions in Node.js 20, and the seatbelt philosophy to protect against malicious code. Discussing the importance of maintaining up-to-date Node.js versions and using tools like npx isMyNodeVulnerable for security checks. Discussing the importance of Node.js security releases, funding, and dependency vulnerability assessment for a safer Node.js environment. Using Node.js Dependency Vulnerability Assessment to evaluate and address potential vulnerabilities, ensuring automated security checks and updates for a safer Node.js environment. Automating Node.js security release process, including configuration files for dependencies, extensive testing across various environments, and creating security release issues and blog posts automatically. Support for various environments, extensive testing with over 55 suites and 5,000 unit tests, automation efforts to streamline processes, and the establishment of a maintenance threat model for enhanced security measures. For a single pull request, it takes six hours to run tests, automation efforts in progress, maintenance threat model to address security risks, permission model roadmap, ongoing discussions on security reports, and plans for the Node.js Collaborator Summit. Active community involvement in Node.js security development, four security releases from 2024 to 2026 addressing various vulnerabilities, end-of-life version strategy with Node.js 16 and 18 having high weekly downloads, and the approach to issuing CVEs for end-of-life versions. Node.js project's strategy adjustment for CVEs to include end-of-life versions, importance of Node.js threat model, trust boundaries, and developer responsibilities. Node.js protection against network data, upgrade recommendations for different Node.js versions, and upcoming changes in Node.js release schedule.
Node.js: More Threads Than You Think
React Advanced 2025
32 min
Node.js: More Threads Than You Think

The talk covers a range of topics including Node.js evolution to a multi-threaded system, scaling with the cluster module, managing PM2 for efficient orchestration, challenges in SSR frameworks, TCP SO reuse port for resource utilization, VAT architecture for smart service routing, zero downtime deployment with shared cache, performance benchmark results, PM2 performance challenges, legality and functionality of TCP SO reuse port, kernel balancing considerations, tool comparison between PM2 and Deno, cache consistency challenges, VAT architecture with worker thread recovery, T-scaling for vertical scaling, and updating Node V6 applications.
Stop Paying for AI APIs: npm Install Your Way to In-Process Inference
Node Congress 2026
26 min
Stop Paying for AI APIs: npm Install Your Way to In-Process Inference

Introduction by Ed Silva, a Node.js core collaborator, discussing the significance of AI in 2026. Companies facing challenges in AI implementation, focusing on AI integration and the need for developer skills. Demonstrations of Node.js egg cooking using Hug and Face community and model inference with Hug and Face Transformers. Transformers JS extending NLP to computer vision and audio tasks, utilizing O-N-N-X format for model execution. Tasks and examples available in Transformers.js for NLP and computer vision, emphasizing model differentiation and execution processes. Optimization techniques for model download trade-offs, GPU utilization, and experimentation possibilities with models like Hugging Face.
Testing
Think Like a Tester: What to Look For in AI-Generated Code
JSNation 2026
16 min
Think Like a Tester: What to Look For in AI-Generated Code

Developers and QA engineer Wendy discuss the challenges in development and testing, using John's experience as an example. John encounters challenges with expired coupons affecting the checkout process and sprint deadlines. Developers and testers have complementary perspectives in software development; introducing the concept of QAI for enhanced quality assurance and collaboration. The QAI introduces a new perspective to code development, focusing on thorough alignment and error scanning for enhanced quality assurance. The importance of code alignment in development, the consequences of silent failures, and the necessity of handling potential hidden failures with a security-focused approach. AI builds fast and trusts everything, teaches suspicion, identifies trust gaps, and addresses accessibility failures for a secure code environment. Every team has patterns to anticipate, leveraging skills for immediate help, and focusing on effectiveness and protection in AI development. John and I collaborate using QAI to enhance code effectiveness, prioritize code alignment, fix contradictions, and address hidden failures effectively. Ship clean code timely, find bugs early to save time and trust. AI and QAI enhance speed and safety in development. Wendy emphasizes the importance of detecting bugs early and the impact on user trust and deadlines.
AI Can Generate Tests for You, Now What?
JSNation 2026
22 min
AI Can Generate Tests for You, Now What?

Living in an exciting yet worrisome period, AI enhances productivity by generating tests. Considerations on scaling AI beyond test generation for high-quality products. AI simplifies test generation but raises quality concerns. Testing dependencies impact code validity. Overreliance on tests doesn't guarantee code safety. AI-generated tests may introduce hidden doubts. Workflow changes with AI assisting in performance, accessibility, benchmark, compliance, and setting up pipelines based on thresholds and risk assessments. Guidelines for working with AI as a team member, emphasizing the importance of standards, review checklists, and safeguarding code. Metrics, learning loops, and strategic improvement for better workflow scalability and testing model quality.
A Leak in the Shell – How Refactoring Autocomplete Broke Us and How We Fixed It
JSNation 2026
26 min
A Leak in the Shell – How Refactoring Autocomplete Broke Us and How We Fixed It

The speaker presents a project to enhance autocomplete in a database CLI using TypeScript, discusses challenges with memory errors in testing, delves into Node.js memory management, explores system contexts and heap snapshots, examines JavaScript memory retention, evaluates the impact of context and eval on memory, uncovers Node.js core bugs and memory leak testing complexities, highlights the use of HeapSnapshots for memory leak detection, emphasizes the importance of application understanding in debugging, and stresses the significance of testing procedures and managing separate heaps.
Automated Accessibility Testing in React: Beyond the Basics
React Advanced 2025
9 min
Automated Accessibility Testing in React: Beyond the Basics

Introduction to Accessibility Testing in React applications, emphasizing early automation and challenges in scaling. Importance of instant feedback, Unity test, and entry testing for code accessibility. Utilizing end-to-end testing tools like Jest-Axi and Cypress to ensure accessibility compliance. Emphasis on manual testing alongside automated tools. Encouragement for discussions on LinkedIn to enhance accessibility knowledge.
Fast-Tracking Quality for Hundreds of React Applications With Automated Testing Layers
React Advanced 2025
29 min
Fast-Tracking Quality for Hundreds of React Applications With Automated Testing Layers

Discussion on improving release cycles and testing efficiency, transitioning to React Native, quality assurance challenges addressed through redefined responsibilities and test automation, shift-left approach for early testing and diversification of automated tests, efficient test execution with caching strategies, impact of caching on CI performance, efficiency with change recognition and caching, project-specific approaches for testing, test optimization with AI and Pyramid test structure, QA team transitioning to engineering, handling unautomated tests and test association, maintaining test stability with Git revert strategy.
Ashes to Ashes, Spec to Spec: The Rebirth of Modern Testing
React Summit 2026
29 min
Ashes to Ashes, Spec to Spec: The Rebirth of Modern Testing

Gathering to bid farewell to Mocha, Jest, and Karma. From minimalism to Jest's migration with Vitest as the most popular framework. Yunus emphasizes finding the right balance in software tools like Angular and NX. Discussion on transitioning from Jest to VTest with a focus on careful approach and test migration efficiency. Insights on debugging mocks, object mothers, and the use of Wallaby JS for debugging in VTest. Exploring test control, browser debugging, configurations, troubleshooting user events, automation with Playwright, and VTest's automation engine. Focus on unit testing speed, scope, and complexity rules, IDE tools like WallabyJS, and GitWipe alias for development reset.
The 2025 State of JavaScript Testing
JSNation US 2025
27 min
The 2025 State of JavaScript Testing

Speaker reflects on the importance of testing, shares insights from the state of JS survey, and discusses future plans for JavaScript testing in 2025. Companies are exploring testing tools and methodologies based on surveys and personal data. Evolution of testing practices from browser to node-based environment with VTest adoption. Advancements in testing technology include VTest's role, Playwright for end-to-end testing, and comprehensive testing solutions. Progress in self-healing tests, AI integration, and tool resurgence like Storybook and MSW for API mocking. Diverse opinions on testing in 2025, with a focus on static analysis, VTest, and end-to-end testing resurgence to browser.
Upcoming events
Subscribe to the top Dev conferences
and grow in-depth as engineer and tech leader with insights from library authors, core teams and experts from top tech companies
Learn more








































































