Talks from our events
Latest
All talksThe Evolution of App Development
React Summit 2026
27 min
The Evolution of App Development

William, a portrait painter in the 1800s, dedicated to achieving the truest likeness through anatomy and light. The evolution of building apps with Expo, a framework for React Native, adapting to changing landscapes to enhance user experience. Newbies in mobile development face reduced barriers to entry. AI's impact on new app development: knowns, unknowns, pitfalls. Breaking tutorial into two parts for easier learning and using AI to verify AI. Expo emphasizes skills and tailored MCP for development. Developers' job evolution to more strategic roles. Advice on overcoming the Dunning-Kruger effect and effective training methods for developers. Empowering new developers with AI for better understanding and mentorship experience.
Taking a Dump: Using Heap Dumps to Find and Fix NodeJS Memory and CPU Problems
JSNation 2026
22 min
Taking a Dump: Using Heap Dumps to Find and Fix NodeJS Memory and CPU Problems

Talking about using heap dumps to find and fix Node.js memory and CPU problems. Starting with a horror story of server crashes and memory leaks in Node.js environment. Exploring why memory leaks occur in JavaScript and how garbage collection works in programming languages. Memory leaks can occur in garbage collected environments. Understanding how garbage collection works in JavaScript and general programming languages. Exploring the mark and sweep phases of garbage collection to identify and reclaim unreachable objects. The garbage collection process involves two phases: mark and sweep. Objects not reachable from roots are marked for removal. The issue arises when objects can still be reached, causing memory leaks like with unbound caches. Memory leaks can occur due to global references or unclosed hooks causing objects to remain in memory, leading to potential memory overflow. Memory usage fluctuates due to garbage collection cycles, which prevent memory leaks by releasing unused memory. A memory leak leads to increasing memory and CPU usage, potentially causing system unresponsiveness. Pinpointing memory leaks is challenging as they affect the entire application, often appearing in production environments. Heap and memory dumps help analyze memory issues, generated in multiple ways like DevTools and command line. Exploring memory usage through Node.js application launch, debug mode, and heap snapshot analysis in Chrome DevTools. Exploring memory snapshots and pinpointing memory leaks by creating diffs between snapshots to identify leaked objects and their references for easy fixes. Exploring different methods for generating memory snapshots, including CLI flags, experimental node flags, and API usage, to efficiently identify memory leaks and manage heap dumps in Node.js environments. Discussing security considerations, challenges in memory leak detection, utilizing heap dumps for resolution, and emphasizing the importance of data security and verification in fixing memory leaks.
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.
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.
Learnings From 100+ Experiments Comparing LLMs for AI Coding
AI Coding Summit London
28 min
Learnings From 100+ Experiments Comparing LLMs for AI Coding

Introduction to LLMs from a Developer's Perspective, YouTuber with AI Coding Daily channel, evaluates new models and versions on YouTube, gaining traction and positive feedback. Exploring the Best Models: My Benchmark on 18 LLMs, evaluating cost, points, and competition among models for day-to-day use. Measuring Models: Prompt Methodology, Tests on PHP, Laravel, React, TypeScript, and CSV, with emphasis on correct data usage and benchmark awareness. Model Evaluation: Chinese models' progression, benchmark awareness, and Opus and GPT superiority. Model Pricing and Quality Comparison: Opus, GPT, and Composer 2.5 cost-effective options. Composer 2.5 and GPT 5.4 mini offer quality at low prices. Choosing models based on project needs and budget constraints. Discussion on local LLM investment challenges, SONnet 5 benchmark performance, and exploration of new models like Proton Luma 2.0. Importance of skill definitions for model performance and limitations in local model implementation. Discussion on the importance of model harness, setup considerations, and evaluation methodologies for LLMs.
Protecting Your Cookies from Hackers and Hungry Developers!
React Summit 2026
27 min
Protecting Your Cookies from Hackers and Hungry Developers!

Mohamad from ING Bank discusses cookie origins and functions, exploring storage, encryption, and security measures. The talk delves into enhancing security through attribute settings, value generation, and decoding manipulation. It also covers domain, path setup, expiry, XSS vulnerability prevention, and Same Site vs. Same Origin comparisons. Additionally, it touches on GitHub.io complexity, Same Site attribute effects, default values, Chrome settings, and managing cookie partitioning with the Secure flag.
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.
For Agents, By Agents: Building AI Tools That Maintain Themselves
AI Coding Summit London
23 min
For Agents, By Agents: Building AI Tools That Maintain Themselves

Rudhankariyam discusses AI-driven coding to develop self-maintaining AI tools. Introduced an open-source project, App Store Connect CLI, as a case study for AI-driven coding. Implemented automation for App Store publishing using agents and APIs. Managed fewer PRs in bulk, used codex and cursor cloud automations efficiently. Added aliases for hallucinated cloud code commands, improved descriptions and examples. Implemented separate auditor agent for rigorous code review. Emphasized human decision-making for product direction and initial rules in automation strategies. Evaluate model quality based on error rates and user expectations. Highlighted the importance of human judgment in software development amidst AI advancements.
Your React App Doesn't Need All That JavaScript
React Summit 2026
27 min
Your React App Doesn't Need All That JavaScript

Using excessive JavaScript in React apps leads to unnecessary complexity, especially for simple tasks like dark mode toggling. Leveraging CSS for dark theme implementation in React can simplify architecture and avoid overengineering. Considering React's role in handling basic tasks like user preferences and theme switching. Exploring the efficiency of CSS in React components for theme switching and parent styling, showcasing simplicity and effectiveness. Highlighting the performance impact of JavaScript loading on page loading speed in slow internet scenarios. Emphasizing the benefits of semantic HTML for accessibility and accordion features. Discussing the importance of staying updated in web development and utilizing popular patterns. Exploring modal implementation simplicity and the ease of using popover for modals and scroll animations. Comparing JavaScript and CSS for scroll animations efficiency and main thread impact on scroll rendering. Showcasing innovative CSS features like carousel implementation, scroll buttons, and customizable select elements for web development.
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.
Featured
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.
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.
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.
Rethinking Bundling: Why You Don’t Need Less JavaScript
JSNation US 2025
30 min
Rethinking Bundling: Why You Don’t Need Less JavaScript

The speaker, Daniel, shares insights on his role as an open source maintainer, projects Nuxt and Nitro, and living in Edinburgh. Nuxt, a full-stack framework, evolved with community support, emphasizing community-driven development. Optimization strategies for JavaScript, CSS, and font loading in Nuxt were discussed. Integration of Nuxt Scripts for web performance, challenges in meta framework development, and considerations for Nuxt V3 rewrite were highlighted. Future plans include smoother migrations and open-source access to emoji slides integration.
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.
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.
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.
Never Worry About CORS Again
JSNation US 2025
28 min
Never Worry About CORS Again

Talk on Bund: Overview of Bund, its speed optimization, components like runtime, package manager, test runner, and bundler. Efficient features include fast npm manager, pnpm lockfile support, Jest-compatible test runner, and optimized runtime components. Built-in features like modern password hashing, WebSocket server, file glob API, and database clients. API design focuses on common use cases and optimization. Enhanced JavaScript functionality with SIMD, native code, and performance improvements. Challenges in JavaScript productivity, BUN adoption, deployment, and support. React support, community involvement, security, Next.js compatibility, and transition.
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.
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.
Trending today
Agents on the Canvas With tldraw
Web Engineering Summit 2026
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.
Optimizing HTML5 Games: 10 Years of Learnings
JS GameDev Summit 2022
33 min
Optimizing HTML5 Games: 10 Years of Learnings
Top Content

PlayCanvas is an open-source game engine used by game developers worldwide. Optimization is crucial for HTML5 games, focusing on load times and frame rate. Texture and mesh optimization can significantly reduce download sizes. GLTF and GLB formats offer smaller file sizes and faster parsing times. Compressing game resources and using efficient file formats can improve load times. Framerate optimization and resolution scaling are important for better performance. Managing draw calls and using batching techniques can optimize performance. Browser DevTools, such as Chrome and Firefox, are useful for debugging and profiling. Detecting device performance and optimizing based on specific devices can improve game performance. Apple is making progress with WebGPU implementation. HTML5 games can be shipped to the App Store using Cordova.
5 Best Practices for Preventing Chaos in Tailwind CSS
React Advanced 2024
10 min
5 Best Practices for Preventing Chaos in Tailwind CSS

Today we're going to talk about best practices for using Tailwind CSS. Tailwind CSS is a popular and controversial tool. It balloons within developers into two opposing camps. For some tasks, Tailwind is extremely cool. After working with Tailwind for a long time, I have identified two main requirements where Tailwind is suitable, and without them, it's better to choose an alternative tool. The first requirement is the project must have a design system. The second requirement for using Tailwind CSS is that your project must have a component approach. If you have a design system and a component approach, then Tailwind CSS may be a nice option for you. Instead of specifying the same margin at the top or the bottom, you can specify only a vertical one. Second rule while working with Tailwind is group design tokens and name them semantically. Rule number three, keep class ordering. The next advice for using Tailwind will be useful not only for Tailwind, but also when working with any content tools, monitor the bundle size and try to optimize it. The last rule for Tailwind, use sets of style variants to avoid problems when overriding classes. Instead of passing classes arbitrarily via props, define a set of variants for the component. Use fewer utility classes, group design tokens, and name them semantically. Keep class ordering, minimize your build size, and use sets of style variants. Remember that Tailwind CSS is a useful tool, but not the only solution for all projects.
Skill Design for LLM Agents
AI Coding Summit London
24 min
Skill Design for LLM Agents

Minko Getschev, AI lead at Google, shares insights on building effective agent skills, including architecture, skill creation best practices, and evaluation methods. Agent decision-making, planning, and hybrid architectures are explored, with a focus on the React loop for tool utilization. Context expansion and management, utilizing tools like MCP and CLIs, enhance agent power. The discussion includes comparisons between MCP and CLIs in agent systems, emphasizing context handling and debugging. Agent skills are structured as procedural instructions, with an open standard focused on tasks and workflow logic. Best practices for skill workflow involve avoiding redundancy, optimizing front matter, and focusing on predictable execution. Utilization and management of agent skills are crucial for performance optimization. Continuous skill evaluation, testing, and improvement are highlighted, with SkillGrade for evaluating agent skills. Skill workflow execution analysis involves identifying failures, log analysis, and rerunning workflows for successful execution.
Conquering React Concurrency
React Summit 2026
25 min
Conquering React Concurrency

The talk at React Summit 2026 by Ariel covers the importance of React concurrency in improving user experience. It delves into the concepts of concurrency, contrasting it with parallelism, and emphasizes the historical relevance of efficient task handling, like the McDonald's kitchen design in 1942. Operating systems use round-robin scheduling for fair process execution. React 18 addresses user impatience and rendering challenges through concurrency. The evolution of React's rendering process from stack reconciliation to fiber reconciliation is highlighted, emphasizing the role of Suspense in managing work prioritization and background rendering efficiently.
I Would Never Use an ORM
JSNation 2023
29 min
I Would Never Use an ORM
Top Content

Welcome to a talk on Object-Relational Mapping (ORM) and its potential pitfalls. The speaker discusses issues with modals and the MVC pattern, as well as the benefits of structuring code around system features instead. They introduce PlatformaticDB as a solution for easy backend development, showcasing its deployment and testing capabilities. The talk also covers integrating with Next.js, writing custom SQL queries, and the speaker's plans for future support and database compatibility.
Interviewing in the Post-LLM World
TechLead Conf Amsterdam 2026: Adopting AI in Orgs Edition
29 min
Interviewing in the Post-LLM World

Companies face challenges in adapting interviewing processes to the post-LLM world. Effective interviewing strategies involve understanding job requirements and tailoring questions. Enhancing the interview process includes skills like preventing prompt injection and assessing curiosity and learning agility. Assessment techniques focus on code understanding, system design evaluation, and deep questioning. Bias reduction, adapting processes, and rewarding applicants' time are crucial aspects of interview processes.
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.
De-bloating the Web: The "Ecosystem Performance" Initiative (e18e)
JSNation 2026
20 min
De-bloating the Web: The "Ecosystem Performance" Initiative (e18e)

The Ecosystem Performance Initiative (E-A-T-N-E) focuses on modernizing the JavaScript ecosystem by reducing redundant, bloated, and unmaintained packages. Efforts aim at cleanup, optimization, and maintenance to enhance project performance and stability. Success stories include significant package size reductions and speed improvements in tools like prettier CLI and Astro. Adoption of lean alternatives like TinyGlobby and development productivity tools like E18e CLI are highlighted. Initiatives include GitHub actions for dependency monitoring, framework performance evaluation, and plans for collaboration, community growth, and ecosystem impact.
Building a Mobile App with Expo, EAS, and React Native
React Summit Remote Edition 2021
35 min
Building a Mobile App with Expo, EAS, and React Native
Top Content

This talk provides an overview of building React Native apps with Expo and Xcode. It covers Expo managed projects, XO, Turtle, customizing runtime, Expo Development Client, and EAS. The talk also mentions the advantages of Expo Updates, the focus on a customizable runtime, and adding native libraries. Favorite React Native apps and libraries are recommended, and the future goals include enhancing performance and improving the development experience through EAS.
Short takes
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.
Using Spec-Driven Development for Production Workflows
JSNation US 2025
7 min
Using Spec-Driven Development for Production Workflows

We're discussing spec-driven development and the innovative AI IDE, QIRO, that supports this approach. QIRO focuses on structured specifications before coding, aiding developers in creating designs. The QIRO mascot, a playful ghost, symbolizes the essence of spec-driven development. Eric Hanchett discusses QIRO, emphasizing its spec-driven development feature integrated into the IDE. QIRO aids in in-depth feature planning, resembling a structured requirements approach. Coding assistants benefit from detailed examples for efficient development. Exploring Manual Coding Assistance: Creating user requirements, building design documents, and task lists manually. Example of using spec mode in a coding assistant to break down requirements, create designs, and implement features.
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.
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.
A JS Dev's Guide to Not Dismissing Blockchain
JSNation US 2025
8 min
A JS Dev's Guide to Not Dismissing Blockchain

Brian Wipo, Developer Relations lead at the Algorand Foundation, discusses the relevance of blockchain in 2025 and its impact on developers. Algorand's high-performance blockchain addresses key issues faced by other platforms, enabling new markets and real-world applications like tokenized assets and supply chain traceability. In 2025, blockchain excels in disintermediating markets, tracking data integrity, and creating new markets such as fractional ownership of assets. Real businesses on Algorand include tokenized solar panels, real estate ownership, supply chain traceability, and more. Using a para wallet with a mastercard debit card, you can buy items at the store with stable coins. Algorand TypeScript 1.0 simplifies writing smart contracts on the chain in TypeScript. TypeScript developers can now integrate blockchain using a compiler that transforms code into Teal assembly language for blockchain execution.
I Did Everything Wrong So You Don't Have To
React Summit 2026
6 min
I Did Everything Wrong So You Don't Have To

Angel from ImageKit demonstrates the use of MCPs to improve image and video performance on React websites. The Chrome Developer Tools MCP helps identify and address performance issues by analyzing image loading speeds. MCPs automate issue resolution on websites, leveraging Chrome developer tools for analysis and Image Kit for optimizing images efficiently.
Organic Leadership in the Age of AI: Why human Touch Becomes More Valuable Than Ever
TechLead Conf Amsterdam 2026: Adopting AI in Orgs Edition
8 min
Organic Leadership in the Age of AI: Why human Touch Becomes More Valuable Than Ever

Reflecting on the integration of AI in software development and the implications for leadership and decision-making. AI integration in leadership: embracing context, judgment, and accountability. Principles: Context before output, Intent before optimization, Awareness before efficiency, Accountability before automation. Leadership as an ecosystem with roots, stem, and fruit; AI's role in each part. Using AI at different levels of leadership: fruit, stem, and roots. Decision-making needs context. Leadership bridges information and context gaps. AI for efficiency but human touch for depth and understanding.
How To Get The Most Out Of the Cloud As A Front-End Developer
React Summit US 2025
7 min
How To Get The Most Out Of the Cloud As A Front-End Developer

Front-end developers benefit from cloud services like AWS S3 and Lambda. AWS offers services like Cognito for identity management and Bedrock AI models. AWS Amplify provides Hosting and Cloud Development Kit for efficient development. The Cloud Development Kit is recommended for TypeScript deployment. AWS Amplify connects front-end to AWS services and SDK for back-end. QR code feedback is available for the talk.
MCPs: How to Avoid Security Pitfalls
AI Coding Summit 2026
7 min
MCPs: How to Avoid Security Pitfalls

Gil Friedman from Backslash Security discussed MCP security, focusing on the Model Context Protocol and AI assistant security risks like GitHub token exposure in auto run mode. Security measures for MCP usage include setting autorun to ask every time, postmarking MCP incidents, handling malicious servers, safeguarding sensitive information, reviewing and disabling unused tools, requiring permission before triggering actions, removing MCP from environments, and revoking API keys when necessary.
Debugging Performance With AI
JSNation 2026
6 min
Debugging Performance With AI

The talk explores using AI to address challenges in rendering performance optimization, highlighting the potential of tools like Chrome developer tools MCP. Leveraging AI with these tools can streamline the process and flatten the learning curve for developers. The approach of isolating performance issues through commit analysis, including systematic testing and synthetic stress tests, is emphasized as a practical method to identify and resolve rendering performance issues effectively.
Popular
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.
Using React to Build Performant Game UIs in Minecraft
React Advanced 2021
25 min
Using React to Build Performant Game UIs in Minecraft
Top Content

This Talk introduces the use of React and web technologies for building UIs in Minecraft. It discusses the challenges of onboarding new developers to the current tech and the benefits of using open standards. The speaker explains the use of Gameface, a solution for building game UIs with React and Webpack. The Talk also covers state management in a game environment and the use of facets for performance optimization. It concludes with an overview of the Oryui brand and the availability of resources on GitHub.
Thinking Like an Architect
Node Congress 2025
31 min
Thinking Like an Architect
Top Content

In modern software development, architecture is more than just selecting the right tech stack; it involves decision-making, trade-offs, and considering the context of the business and organization. Understanding the problem space and focusing on users' needs are essential. Architectural flexibility is key, adapting the level of granularity and choosing between different approaches. Holistic thinking, long-term vision, and domain understanding are crucial for making better decisions. Effective communication, inclusion, and documentation are core skills for architects. Democratizing communication, prioritizing value, and embracing adaptive architectures are key to success.
Config Driven UI using ReactJS
React Summit 2023
7 min
Config Driven UI using ReactJS
Top Content

This lightning talk introduces config-driven UI in ReactJS, a technique for creating dynamic and customizable UIs without hard coding. It covers the implementation of different types of components and how they can be nested to create complex layouts.
Modern Web Debugging
JSNation 2023
29 min
Modern Web Debugging
Top Content

This Talk discusses modern web debugging and the latest updates in Chrome DevTools. It highlights new features that help pinpoint issues quicker, improved file visibility and source mapping, and ignoring and configuring files. The Breakpoints panel in DevTools has been redesigned for easier access and management. The Talk also covers the challenges of debugging with source maps and the efforts to standardize the source map format. Lastly, it provides tips for improving productivity with DevTools and emphasizes the importance of reporting bugs and using source maps for debugging production code.
Vue: Feature Updates
Vue.js London 2023
44 min
Vue: Feature Updates
Top Content

The Talk discusses the recent feature updates in Vue 3.3, focusing on script setup and TypeScript support. It covers improvements in defining props using imported types and complex types support. The introduction of generic components and reworked signatures for defined components provides more flexibility and better type support. Other features include automatic inference of runtime props, improved define emits and defined slots, and experimental features like reactive props destructure and define model. The Talk also mentions future plans for Vue, including stabilizing suspense and enhancing computer invalidations.
How to properly handle URL slug changes in Next.js
TypeScript Congress 2022
10 min
How to properly handle URL slug changes in Next.js
Top Content

This Talk explains how to handle URL slug changes in Next.js by using the getStaticPaths and getStaticProps methods. It covers implementing redirects and provides a solution to eliminate the need for editors to perform additional steps. The approach involves tracking URL slug changes and issuing proper redirects. The speaker encourages the audience to reach out with any questions or experiences with handling URL slugs.
Unreal Engine in WebAssembly/WebGPU
JS GameDev Summit 2022
33 min
Unreal Engine in WebAssembly/WebGPU
Top Content

Alex Saint-Louis, co-founder of Wunder Interactive, shares the mission of bringing Unreal Engine to the browser, enabling cross-platform 3D applications and games. They are working on a WebGPU back end for Unreal Engine to push the limits of 3D on the web. Wunder Interactive has improved compression, built their own asset file system, and offers powerful tools for game developers. They are utilizing modern web technologies like WebAssembly, WebGL, and WebGPU, and plan to support other engines like Unity and Godot. The team aims to transform the industry by bringing console-quality games to the browser and providing an alternative distribution path. They are excited to bring Unreal Engine 5 to the web with WebGPU support and are working on WebXR support for cross-platform 3D experiences, including VR.
Handling Breaking Changes in GraphQL
GraphQL Galaxy 2022
22 min
Handling Breaking Changes in GraphQL
Top Content

This Talk discusses handling breaking changes in a GraphQL schema, including the use of the deprecated directive to tag fields that should no longer be used. It also covers the process of deploying GraphQL APIs and mobile apps, highlighting the challenges of mobile app release adoption. The Talk emphasizes the importance of making safe upgrades in mobile apps and provides strategies for detecting and handling breaking changes, such as using TypeScript and GraphQL Inspector. Overall, the Talk emphasizes the need to minimize user impact when introducing breaking changes in GraphQL schemas.
You Can’t Use Hooks Conditionally… or Can You?
React Summit 2023
28 min
You Can’t Use Hooks Conditionally… or Can You?
Top Content

The Talk discusses the use of the Use hook in React and its ability to be used conditionally. It explains the concept of the fiber tree and how hooks values are stored in memory. The Talk also delves into the conditional use of useContext and how it differs from useState. It explores the process of updating context values and optimizing context rendering. The role of the provider in managing context values and rendering is emphasized.
React
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 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.
Real-World Hydration and Rendering Patterns in Modern React Apps
React Summit 2026
20 min
Real-World Hydration and Rendering Patterns in Modern React Apps

Ranjit Dandigam discusses real-world hydration and rendering patterns in modern React apps, exploring UI rendering phases, optimization strategies, and the importance of server-client boundaries. Implementing a streaming strategy in React apps enhances loading efficiency and user experience. Managing hydration mismatches and implementing safe time patterns are crucial for stable rendering. Demonstrations of Next.js rendering variations highlight different approaches to rendering content. Design principles for React app rendering emphasize the significance of streaming with suspense and honesty in rendering decisions.
Plug and Play Design: Building Extendable React Applications
React Summit US 2025
29 min
Plug and Play Design: Building Extendable React Applications

Mateusz Jagodziński, principal developer at Synergy Codes, shares insights on Plug and Play Design Building Extendable React Applications, discussing feature flags, modularity, and real-world use cases. Challenges of feature flags, the concept of alternative modular design for feature management, and the importance of modularity in code organization and development. Configurability and limitations in feature management, showcasing a plugin-based design for flexible tool versions and code manipulation. Explanation of plug and play design for code manipulation and version control with full type safety in TypeScript projects. Exposing functions to register new plugins, organizing plugins' logic within individual folders, and implementing a build setup with a replacement mechanism for plugin files. Replacing missing plugins with a fallback code, enforcing restriction on direct plugin imports, and visualizing the relationship between plugins, adapters, and application components. Exploring pros and cons of self-contained plugins, addressing implementation overhead, and discussing the value of enforced modularity for AI coding tools. Discussing plugin management decisions based on client needs and the scalability of the approach with changing requirements and minor tweaks. Handling plugin version tracking, automated testing challenges, and feature control based on environments. Adapters and maintaining plugin compatibility through iterations and cosmetic changes, leveraging existing solutions for simplicity. Discussing the implications of not shipping separate builds for multiple customers and considering the benefits of smaller bundle size. Exploring the ease of trying out new features with separate plugins to assess overhead and developer experience.
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.
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.
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.
Suspenseful Component Composition
React Summit US 2025
12 min
Suspenseful Component Composition

Simeon Griggs discusses Suspenseful Component Composition, the use of fallback props, and the basics of suspense in React applications with a demo showcasing data fetching and layout shifting. Exploring issues with data fetching and suspense boundaries. Addressing the challenges of using suspense boundaries and data fetching for individual rows in React applications. Creating consistent fallback elements for smooth loading experiences in tables by aligning sizes and optimizing data fetching placement. Optimizing data fetching placement for smoother loading experiences. Consider exporting suspense boundary to enhance code cleanliness and be defensive against data fetching errors. Use error boundaries to handle errors in suspenseful data fetching components for a smoother user experience.
React on the Edge
React Summit 2026
17 min
React on the Edge

Welcome to React on the Edge with Amir Sami from S&C Electric exploring React applications for diverse Edge devices beyond browsers. The discussion covers deploying React apps to various Edge devices, addressing challenges like network stability and resource limitations, optimizing bundle size with Preact, and using Brotli compression for efficient web asset compression on Edge devices.
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.
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.
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.
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.
Life of an ESM in Node.js – and How It's Changing for the Better
JSNation 2026
29 min
Life of an ESM in Node.js – and How It's Changing for the Better

Talk about the fundamentals of ESM in Node, Node's resolution process for imports, challenges with TypeScript and Node's resolution, customizing module resolution in Node, handling source code loading, loading and parsing modules in Node, module compilation and dependencies, bytecode reuse and instantiation in Node and V8, revamping API design and ESN namespace mutability, deferred evaluation and idempotency in ESM, ESM misconceptions and circular dependencies, and the future of TypeScript loading and performance improvements.
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.
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.
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.
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.
Testing
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.
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.
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.
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










































































