AI coding tools are good at writing local diffs, but they still miss repo-wide truth. In large TypeScript and JavaScript codebases, that means dead exports, duplicated logic, accidental boundary violations, and complexity creep after every “small” AI refactor. In this talk, I’ll show a practical workflow for working with large codebases using AI: let the agent generate, run deterministic codebase analysis, feed the findings back via CLI/MCP, and gate drift in CI before it lands. Fallow is the case study, but the workflow applies beyond one tool.

Anyone can spin up an AI agent in five lines. Would you give that agent a refund button? In this demo-driven talk I build a customer support bot with LangGraph, the framework behind agents at Klarna, Uber, and J.P. Morgan, to show why control matters in production. Instead of letting the model improvise, I lay the bot out as a graph: it answers the easy questions on its own, pauses for human approval before anything irreversible like a refund, and resumes where it stopped after a crash. Then I ship it to AWS. Claude on Amazon Bedrock runs the model, Amazon Bedrock AgentCore hosts the bot, and the Agent Toolkit for AWS handles model access, IAM, and deployment from inside the coding agent. You'll leave knowing how to start with LangGraph, how to run it on AWS without a platform team, and when a graph beats a free-roaming bot.

What can more than 20M public GitHub commits tell us about Claude Code's reach? In this talk, we move beyond vendor narratives to look at the real data: which developers are using Claude Code, what they're building, and crucially, what kinds of problems it's being applied to at the serious end of the stack.

Developer tools are no longer built only for humans at a terminal. They are also used, tested, broken, and improved by AI agents.

In this session, I will share how to create tools where you can have agent-reported issues, automated reviews, refactors, and release workflows to the point that such tools start to maintain themselves, and help one maintainer operate closer to a small team.

We thought AI would help us write code faster. Instead, it's changing what coding actually is.
We started with prompts, then copilots, then agents. Each step felt like a leap forward — until you try to build something real at scale.Because prompts don’t remember.
Agents don’t coordinate.
And models still hallucinate and miss context.
What’s emerging instead is a different approach: not writing code line by line, but designing systems that produce, validate, and evolve code.
Instead of a single assistant, we orchestrate multi-agent workflows — planning, implementing, reviewing, and testing — with shared context and feedback loops.In this talk, we’ll cover:
- why prompt-based and single-agent approaches break down
- how multi-agent systems reshape development workflows
- practical patterns for planning, execution, validation, and control loops
- where things fail — and how to make systems reliable

We’ll show how structured orchestration makes agent-based systems actually work in practice — especially when moving beyond isolated, task-level automation.
The shift isn’t from coding to prompting — it’s from coding to designing systems that write code.

This talk dives into how developers can build structured, repeatable coding workflows using Claude Code's ecosystem: Skills, Subagents, settings, Hooks, and MCP servers. I'll walk through the architecture behind Claude Code Templates, an open-source project with 120K+ npm downloads and 23K+ GitHub stars, showing how these components work together to create composable, reusable patterns within real software development projects. From automating code reviews to orchestrating multi-agent tasks, we'll cover practical setups that teams can adopt immediately.

What makes an agent skill reliable, performant, and maintainable? We will explore a robust approach to skill design, starting with foundational best practices, moving into automated skill generation, and validation. The second half of the talk focuses on the critical role of evaluation, demonstrating how tools like SkillGrade and benchmarks like SkillBench allow developers to catch regressions and ensure their agents behave predictably in complex environments.

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.

Himanshu discusses React performance patterns affecting long-running production apps, including memory leaks, event listener accumulation, state value consistency, and dependency array misuse. The talk highlights the risks of race conditions in API calls, uncanceled requests leading to data discrepancies, and the significance of abort controllers for improving app stability and addressing circular dependencies.

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.

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.

Welcome to React Summit 2026. Discussing architecting reliable React systems in unreliable environments. Real-world challenges with async complexity, state management, and app flow impact. Addressing issues with unreliable connections, API failures, and lack of UI-system sync. Managing OTA updates, Boolean soup problem, and useEffect dependency chaos in state management. Dealing with UI state discrepancies, hidden updates, and inconsistencies. Ensuring deterministic system architecture for accurate UI feedback and optimizing state management with clear boundaries and a state machine.

Sharing lessons on building and scaling global React applications. Front-end complexity with business expansion. Challenges of globalization in React development. Impact of market variability on front-end architecture for global scale. Architectural decisions influenced by operational realities. Technical and organizational problems at a global scale. React dual architectures for global scale. Balancing consistency and flexibility in architecture. Issues with business logic in components, scalability, region-specific deployments, and optimizing performance. Organizational challenges with global feature shipping, release conflicts, slow rollout cycles, and configuration duplication. Issues at global scale: technical and organizational challenges. Avoid business logic in components, scalability issues like user spikes, and deployment time. Market logic in components, region-specific deployments, front-end boundary size increase, and fragmented integrations. Multiple teams shipping globally face challenges like release conflicts, slow rollout cycles, and market-driven behavior testing. Complexity increases with more markets, localization goes beyond translation affecting currency, taxes, compliance, and more. Markets vary operationally requiring adaptive platforms for dynamic changes based on market context. Shift to adaptive platform for dynamic market behavior. Configuration as front-end control plane, like Kubernetes. Feature flags crucial for efficient management, operational flexibility. Market-specific capabilities, safe experiments, unstable features disabling. Region-aware routing enhances operational concerns separation, micro front-end usage for improved performance. Optimizing CDN and SEO for market consistency. Region-aware routing for operational separation, micro front-end performance improvement. Front-end observability critical for global scalability. Evaluation for adaptability, avoiding over-engineering. Challenges in global React application evolution, operational maintainability. Considerations for localization, multi-tenant systems, feature-flag scaling, and global architecture challenges.

The speaker recounts debugging an e-commerce application, emphasizing the need for monitoring business logic. They discuss building custom DevTools for specific business logic debugging and explore limitations of React DevTools in handling complex scenarios. The importance of developing custom DevTools architecture, white-coded UI, efficient domain communication, and inspecting DevTools architecture is highlighted. Additionally, analyzing domain inspector functionality, maintaining React DevTools in a monorepo, and ensuring DevTool safety and utility through ongoing maintenance and user feedback are discussed.

Violina discusses fixing front-end bugs caused by backend field renaming at Click My Horse TV. Systems misalignment led to unexpected outcomes due to evolving APIs. Different shapes from APIs caused cross-platform functionality gaps. Drift in domain shapes slowed velocity and exemplified misalignment in the mobile app. OpenAPI contracts improved code reliability and consistency. Spec-driven development ensured backend and frontend alignment through shared schemas. AI-assisted development benefitted from precise specifications. Trustworthy automation processes relied on accurate component scaffolding and reliable AI output. Ownership clarity and spec integrity were crucial for optimizing development workflow. Investment payoff with shared APIs among frontend clients emphasized. Tech depth accumulation highlighted the importance of treating the API as a product with design discipline.

The case study from Zotoo highlights a new fourth platform reshaping the way applications are developed. Meeting user needs across devices presents challenges and opportunities in app development. Scaling challenges and technological evolution involve adopting new technologies like PWA and TWA. Innovative technology approaches with React Native and transitioning to a universal system framework are key focus areas. The organization is evolving its structure towards a stream value organization, optimizing domain focus, and expanding reach with future plans for smart TVs and mobile devices.

Shubham, a senior software engineer at Headout, discusses challenges when React meets real-time systems while working on an internal tool for audio doors. React's flexibility clashes with real-time systems' fixed schedules, causing issues like audio drift. Redefining React's role in real-time systems improves playhead smoothness by shifting architecture. React transitions to an observer, using an external clock for stability. Optimizations in React's rendering architecture include layered rendering for enhanced UI performance. Real-time feedback bypasses React for instant responses, with cache invalidation critical in real-time systems.

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.

You are shipping faster than ever before and feeling something off. Michal Zizo, an earth and space architect, offers a framework for understanding human performance in challenging environments. The 2024 and 2025 Stack Overview Developer Survey shows a paradox in AI tool adoption with decreasing developer trust. Faster outputs lead to less clarity, more responsibility, and increased anxiety around mistakes. Better prompting, workflows, integration. This isn't a skill gap; it's an environmental shift. The gap between expected and actual outcomes is crucial. AI is not just productivity enhancement; it's a significant environmental change. An environmental change requires adapting how you operate. Space architects optimize for human sustainability in extreme environments. Focus on environment, not individual improvement. Fix the environment to address challenges, not the individual. An architect defines the environment as the conditions influencing human perception and action in a system. Key properties include visibility, speed, feedback proximity, error tolerance, and clarity of agency. Architects consciously shape these design conditions. In your work, code complexities challenge visibility and traceability, impacting decision-making and outcomes. Speed of change in environments surpasses individual tracking capabilities, causing systemic errors and accountability challenges. Extreme environments, like space, demand operational adaptation due to complexity and rapid shifts. Communication delays and critical decision-making windows in space highlight the consequences of errors and the importance of quick responses. Errors in complex systems grow in significance. Human accountability remains essential in space operations. Prioritize operability, responsibility, and human sustainability in extreme environments like space. Space is extreme, chaotic, and unforgiving, mirroring your systems. Design for human operation in chaos. Engineers need to rethink environment design for AI operations. Engineering leaders need clarity for decision-making. Responsibility shifts to decision ownership. Velocity redefined for sustainable speed. Humans and AI complement each other in operations. AI handles computation, humans provide judgment. Redefine failure for survivability. Anomalies in extreme environments are data, not failures. Operating in unprecedented conditions. See the environment clearly. Running a mission, not managing tasks. Ad Astra to the stars.

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.

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.

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.

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.

Seungho Park discusses scaling React UI using design tokens and Figma to address UI consistency challenges at LG Electronics. Design tokens managed in Figma and synchronized across platforms using GitHub Actions. Automation of design token updates demonstrated with Figma Sync and GitHub Actions. Shared tokens enable app-wide theme consistency and streamline visual styling with CodeConnect. CodeConnect bridges Figma design to React code, transforming designs with AI and ensuring accurate mapping. Practical insights shared on implementing design tokens for scalable React UI development.

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.

Daniel Avila introduces Cloud Code Desktop, a new platform simplifying Cloud Code usage. Explore features like Cowork, connectors, and plugins. Manage sessions, customize environments, and interact with Cloud efficiently. Understand skills, context, and execution in Cloud Code. Develop comprehensive skills with precise control measures. Optimize skill execution, design interfaces, and implement skills in MCPs. Enhance MCPs with Cloud Skills and advanced installation processes in Cloud Code Desktop.

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.

The Talk discusses the significance of communication, problem-solving, and ownership for senior engineers in software development. It emphasizes the importance of ego management, learning from mistakes, and embracing simplicity for growth and improvement. The key points focus on balancing ownership, avoiding overcomplication, and prioritizing fundamentals and craftsmanship over trendy tools in programming.

Nawal discusses using LLMs for migrating component libraries at Zalando, highlighting challenges and complexities. Discussing a recent migration problem at Zalando involving unification of component libraries and challenges in automating migration process. Encountering limitations with codemods, leading to exploration of LLMs for automated migration processes. Conducting iterative experiments to enhance LLM accuracy in component migration. Building a CLI tool for component migration. Using AIDAR for automating git commits & maintaining LLM accuracy. Recommendation for team closeness to code, successful complex transformations by LLM, challenges with hallucination and ignoring instructions. Lessons learned include field addition, non-deterministic outputs, slow responses, project constraints, and tool evaluation. Evaluating tool enhancements, PROMPT best practices, core approach, improved tools, LLMs for simple migrations, and tool limitations with multiple file changes.

Sylwia Laskowska discusses challenges of frontend legacy migration, importance of legacy system migration for security and performance, considerations for big bang migration strategy, success story of Angular migration, incremental migration with strangler pattern, real-life migration story using feature flags, pitfalls in migration like prolonged timeline, and migration planning and execution strategies likened to renovating an old house.

Sohan Maheshwar humorously recounts feedback on advising against JWTs for authorization, highlighting challenges in payload structure and fine-grained permissions. Scalability and token revocation present issues, along with predicting permissions. Risks of overprovisioning permissions are addressed, with Macaroons as a solution and complexity in access control systems. Modern authorization systems like Zanzibar and Policy Engine prioritize correctness, flexibility, and security over simplicity of JWTs.

Serhii discusses optimizing CI pipelines by prioritizing impactful changes, reducing a merge train pipeline from an hour to 22 minutes through structured approaches, and focusing on failure rates for improved developer trust and system reliability. Adding workers and optimizing Chrome usage in test environments reduced the merged train run time by reprioritizing resources and improving efficiency. Faster CI achieved by reducing unnecessary weight, maintaining trust, and optimizing test retry mechanisms to enhance stability and speed. Counter-intuitively, spending more on infrastructure led to a 64% reduction in merge train time and a 12% increase in CI health, emphasizing the importance of optimizing for the lowest total cost and not just CI cost. Prioritize by return, not convenience. Optimize the system for speed, stability, and cost trade-off to achieve significant improvements in merge train time and test suite performance. Measure pipeline efficiency to identify high-return engineering projects.

Developers write code to make things work. Wendy, QA Automation Engineer, introduces John, a great developer who encounters challenges implementing a new feature. Checkout is critical for the company's existence, emphasizing its importance. When a coupon expires, issues arise with discounts. John faces challenges fixing the code, revealing different perspectives between developers and testers. Developers and testers are partners balancing each other's perspectives. Introducing the QAI for adding QA insights to development processes. Ensuring code matches agreements is crucial. Phase B scans code for potential issues. Code alignment is the gate to address discrepancies between agreements and code. Product oversight in code scenarios. Code failures can be concealed and dangerous. Handling hidden failures is crucial in code development. User faced invisible failures; handled vs. hidden code distinction. Fast code requires a security lens and skepticism. Trust gap between front end assumptions and back end validations. Distinguishing code gaps; AI lacks awareness; critical accessibility issues; distinct code failure types with separate focuses. Utilizing team patterns for efficiency; AI effectiveness through direction with QAI; improving code quality with QAI assistance. Contradiction between PRD and Figma resolved by John; Efficient bug fixing and code scanning; Enjoying exploring edge cases and unique challenges. Importance of clean code for efficient development; Addressing bugs at the right time saves resources; Transition from bug finding in development to production.

Dan Shapir introduces heap dumps to identify and fix Node.js memory and CPU issues. Memory leaks in JavaScript occur when objects are still reachable, impacting memory usage. Continuous memory rise from leaks can deplete memory and lead to CPU usage escalation. Detecting and resolving memory leaks promptly is crucial to prevent system unresponsiveness in production environments. Heap dumps and memory dumps help analyze memory issues, with Chrome DevTools aiding in finding memory leaks. Pinpointing memory leaks involves comparing heap snapshots and analyzing leaked objects. Alternative methods for generating heap snapshots include new experimental node flags, automatic triggers, and built-in APIs, offering benefits but posing risks such as potential crashes and security vulnerabilities.

Claudio Bonder discusses the importance of Node.js documentation and the recent improvements made in developer experience. The evolution of Node.js API documentation has influenced tools and millions of users, with previous outdated tools leading to challenges in maintenance. The introduction of Dockit aimed to revolutionize Node.js API documentation with modern technologies. Dockit enhances documentation generation by supporting various sources, customization through AST and GSX transformation, and ensuring high-quality documentation for Node.js and community projects. The tool's innovative approach prioritizes user experience, collaboration, and strict common mark specification for efficient API doc creation.

The talk discusses system failures in production despite passing tests, emphasizing the importance of spike testing during events like Black Friday. It highlights the consequences of not being prepared for sudden traffic spikes, such as errors, user dissatisfaction, and revenue loss. Common challenges in spike testing include thread pool saturation, database locks, and auto-scaling delays. Setting up a spike testing model involves identifying peak hours, establishing baselines, and creating realistic traffic distribution models to simulate scenarios like Black Friday.

Viola, senior software engineer in London, presents Auth Under Attack to catch JavaScript auth failures in production fast. Auth failures lead to trust state disagreements. Tracing trust boundaries is crucial for accurate investigations. Understanding common failure shapes aids in recognition and resolution. Ensuring strong recovery flows and controls for trust extension are crucial. Permission leaks can occur when old authority persists. Focusing on system inconsistencies and broken trust chains is crucial for diagnosis and resolution. Mapping the system before implementation accelerates issue detection. Groundpact aids in enforcing authentication contracts pre-production, enhancing system security. Authentication aims for consistency and predictability, with CI as a crucial checkpoint to prevent incidents.

Santiago Colombato explains the challenge of synchronizing DOM and WebGL for visually heavy websites, focusing on scroll sync and WebGL basics. WebGL scroll sync involves adjusting canvas position to prevent drift. Optimizing WebGL text rendering includes overcoming drift and clipping challenges. WebGL font rendering complexities include manual handling of text features. Enhancements involve drawing real HTML elements inside the canvas for visual effects. WebXR demos showcase HTML integration in 3D space, emphasizing aesthetics and accessibility.

Voice interaction is evolving rapidly with AI agents moving beyond chat windows. Achieving natural conversations with voice AI presents significant challenges, especially in meeting real-time interaction expectations. Advancements in real-time conversation technology and infrastructure are improving latency gaps in voice apps. Optimizing latency at each stage of voice agent processing is crucial for efficient development. Semantic turn detection and efficient function calling are key to optimizing user experience in Voice AI. Workflow management, cost management, signal recognition, and observability are vital aspects in voice AI development.

Liang introduces MemoryLab, a tool for automating JavaScript memory leak detection. MemoryLab aims to make memory debugging more accessible and scalable by automating the process and utilizing a three snapshot differentiation approach. It clusters similar leak traces to reduce debugging overload and presents representative cluster retainer traces for each memory leak cluster. MemoryLab integrates AI coding tools for memory detection, analysis, and debugging, with the MCP server enabling accurate investigation of memory leaks in heap snapshots.

In the Talk, the most interesting ideas revolve around improving CI speed for over 200 monorepos by addressing waste in the CI process. Strategies include streamlining compilation processes, optimizing deployment by compiling only affected applications, and configuring self-hosted runners with S3 cache to enhance CI pipeline efficiency. Furthermore, enhancements in cache implementation, micro frontend build efficiency, and decoupling translations from CI to parallelize tests and reduce build and test times stand out as key points discussed.

Eric Handshed introduces spec-driven development, emphasizing its benefits in creating high-quality code by writing specs before coding. Spec-driven development involves structured specifications written before coding, enhancing collaboration with language models and coding assistants. The approach guides developers and ensures code quality. Hanchett stresses the importance of guiding large language models with context to ensure they follow the right direction amidst evolving software requirements and paradigms. Be cautious with context in spec-driven development to avoid overwhelming or underwhelming large language models. Use skills to guide coding agents effectively and maintain a human-in-the-loop approach for code review in the spec-driven development process. AWS history lesson leading to Kiro release with CLI option and emphasis on vibe and spec mode for larger projects and complex features. Release of spec-driven development process, manual method without Kiro, Speckit usage in Qro for new and existing projects. Requirements document creation, design document tips, implementation phase tasks with property-based tests, and model context protocol for data source connections. MCP maturation, integration with project management, demo of QIRO IDE for project creation, MVP creation, and property-based tests for requirements satisfaction. Creation of a movie website starting with a design document, generation of property tests using FastCheck in TypeScript, development of requirements document, task list update to create an MVP, implementation of MVP features, and examination of property-based tests.

Exploring web performance, server-side rendering, streaming, and out-of-order streaming to enhance efficiency. Evolution from client-side to server-side rendering for better response. Balancing client-side rendering speed and server-side tasks with hydration. Optimization of rendering processes with server components. Evolution of tech stack addressing server response challenges. Improving rendering efficiency with streaming and Express. Sequential handling of asynchronous components for better user experience. Implementation of server-side loading state and out-of-order streaming for content flow replacement.

Jason Williams, a senior software engineer at Bloomberg and TC39 delegate, discusses contributing to Servo project in Rust. The process of developing Boa JavaScript Engine involved highlighting its speed, memory safety, and performance compared to Gecko. Principles of building a JavaScript engine in Rust are compared to processing plants with stages like tokenization and parsing. Tokenization involves breaking down JavaScript code into tokens following the ECMAScript specification. Boa's community contributions focused on enhancing CPU caching, inline caching, and testing for conformance. The engine successfully implemented Temporal, achieving a high test pass rate and integration into major engines.

Pradeep Shah, senior software engineer at Netflix, explains the complex process of content understanding infrastructure and the challenges of coordinating rule engines, ML models, and human decisions. The system aims to route work efficiently to workers, integrating AI agents and ensuring structured feedback for model retraining. Exploring Orchestration System for Concurrent Workflows: Tracks state across workflows, scales to new types without code changes, and promotes reuse. Efficient data storage and retrieval within Netflix using Raw Holo and Conductor for orchestration functionalities. Workflow system provides notifications, dashboards, and efficient workflow setup with AI and human review. Conductor workflow involves immediate task creation, seamless sub-workflow integration, and decision-making based on task flags. Real-time visibility of tasks in raw holo, structured output for human decisions in Conductor workflow. Integration of human and AI agents into the workflow system for efficient task handling.

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.

Anri Fisher, with over 12 years in tech, focuses on training tech leads and addressing time management challenges. Tech leads shift to a supportive role in empowering team members in growth discussions and one-on-one meetings. Overcoming feedback and delegation struggles through clear communication and expectations is crucial for effective leadership. Strategies for proper delegation include setting clear expectations, agreeing on timelines, and defining processes. Ensuring team alignment, shared timelines, and clear ownership are key for project success in tech teams.

Kitze introduces the purpose of conferences as networking, meeting people, and teaching. The speaker discusses their businesses Sizzy and Benji, emphasizing tools for developers and a life OS solution. They highlight Zero to Shift, Tinker Club, and SuperMac. React's evolution and frontend development advancements are summarized. Vibe coding and management practices are discussed, focusing on quick changes and embracing code nuances. Vibe engineering involves leveraging agents and committing often. Effective prompting, voice dictation, and vibe coding challenges are addressed. AI's impact on programming jobs and the importance of innovation are highlighted. Role-based frameworks like React Cowboys and Fibre engineering's code consistency are emphasized.

Gawe discusses React frameworks, tools, and agents, emphasizing speed and collaboration in building Z, a Rust-based code editor. Z differentiates itself with fast performance, real-time collaboration, and support for diverse platforms. The talk covers new frontend tools, code completion, and linting, highlighting Z's features for React developers. Z offers an open platform, custom theme creation, and deep integration with agents for improved workflows. The founders' journey from Adam to Rust showcases Zed's commitment to performance, open-source UI, and support features like MCP servers and global skill recognition.

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.

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.

Imagine users finally using your app, but costs and server operation raise concerns. Peer-to-peer could offer solutions for managing user traffic effectively. Trust in server reliability questioned. Peer-to-peer discussed for problem-solving and user control through keys and profiles. Users invited to spaces with defined roles. Apps built in distributed fashion. Messages signed with keys for shared truth like blockchain. Deterministic processing of messages. Secure data sharing and access control. Development of SDK for peer-to-peer apps. Defining schemas for apps, like bunk docs. Utilizing middleware for app functionality. Deployment on peer-to-peer for unrestricted access. Peer platform for app development. Ensuring data safety and peer hardware risks. Use of servers as relays for optimal functionality. Exploring P2P power consumption and offline data storage. Considerations for relay servers in P2P networks. Exploring throughput considerations and smart relay service strategies in peer-to-peer networks. Exploring the impact of seeders on bandwidth in peer-to-peer networks and the optional use of relay servers for data transmission, emphasizing the increasing focus on security among developers. Discussing metadata retention in messaging apps, with a focus on Keed's security approach and data distribution in a peer network. Discussing client device synchronization and data storage techniques for maintaining document changes in real-time collaboration applications.

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.

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.

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.

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.

Kiko explores the concept of Dynamic User Interfaces generated by AI based on user prompts and challenges traditional UI generation by focusing on user needs. The implementation involves structuring dynamic UI with LLM calls and enhancing interaction through forms and client state embedding. The talk covers implementing dynamic UI features, utilizing a custom design system, enabling dynamic UI generation by LLM, and discussing use cases and transitions to dynamic UI. It also addresses testing challenges, ensuring user experience through context-based data, and the importance of building reliable AI systems to avoid model hallucination.

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.

Introduction to ARIA, its meaning, and the complexities of accessibility in web development. Exploring the importance of proper ARIA usage for web accessibility and the pitfalls of incorrect ARIA implementation. Exploring the importance of landmark roles in web development and their benefits for screen reader users. Discussing the impact of AI-enabled assistive technologies on ARIA and emphasizing the importance of using semantic HTML. Discussing the importance of visually hidden text in the correct DOM order and the challenges of accessibility for chart-heavy pages. Discussing the importance of testing with users with disabilities, upcoming accessibility requirements for web pages, and considerations for making AI more accessible.

The talk delves into the importance of designing for failure in software engineering, highlighting the significance of resilience in React applications. It emphasizes the challenges of error detection and prevention, introduces resilience patterns like Circuit Breaker, and discusses implementing these patterns in Next.js. The talk also covers managing API retries, handling timeouts, addressing latency challenges, and strategic placement of error boundaries for improved user experience. Additionally, it touches on understanding user experience, error perception, and common anti-patterns in React error handling.

The talk discusses the performance boost achieved by replacing Node.js with Rust and V8 in React architecture. It emphasizes the benefits of server-side components for better performance and reduced bundle size. Challenges of server-side rendering and hydration are highlighted, along with lessons learned from Rust on correcting React architecture. The evolution of route strategies for improved performance, the efficiency of server performance with RARI, and the integration of caching and backend systems in Rari are also explored. Additionally, insights on enhancing RARI with custom Rust endpoints and potential performance improvements by rewriting Next.js in Rust are shared.

Starting with recent comments criticizing the stance on AI and coding, highlighting the divide between senior and junior developers' perspectives. Reflecting on the impact of AI on teaching code and content creation, transitioning to AI-driven teaching methods. Challenges in transitioning to AI-driven teaching focused on critical thinking over syntax. Discussion on scaling AI tools, Bloom's Taxonomy, and the shift to creation-focused development. Importance of critical thinking in software engineering and nurturing junior talents in the evolving industry. AI's role as a teaching tool, concerns about job replacement, and the need for continuous skill growth. The significance of maintaining critique ability in AI output evaluation.

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.

Marc Erickson discusses React rendering fundamentals, optimizing performance, and compiler efficiency. The React compiler optimizes components with memoization and efficiently recalculates changes. React 19 introduces memo cache hook for performance optimization. Enhancements in logic execution, reference optimization, and context changes improve rendering performance. The React compiler impacts re-renders based on props, inputs, and tool transitions. Developing a time-traveling debugger at Replay addresses bug investigation challenges. Understanding code optimization and React build tool transitions are crucial for performance investigation in software engineering.

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.

Eric Rasmussen discusses a new framework addressing current framework issues, focusing on React developers and the evolution of UI concepts. React's reactivity concept prioritizes safety and re-evaluation strategies. Fine-grained reactivity in React tracks dependencies for precise updates. Signals in Solid enable code reruns based on changes. Ripple introduces fine-grained reactivity, readable code, and supports a smooth syntax transition from React. Ripple's state management simplifies updates and effects handling. Ripple's design philosophy offers an alternative approach to React's limitations, emphasizing fine-grained value changes. Ripple stands out for SSR challenges, superior reactivity, and imperative syntax.

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.

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.

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.

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.

Training engineers for proper AI usage without prompt AI dependency. Challenges in ensuring code quality with AI development. Importance of DRY principle in optimizing AI usage. Advocating for effective AI practices implementation with project-specific rules. Establishing AI rules and standards for seamless collaboration. Maximizing AI efficiency with agents mimicking human roles. Encouraging self-education, setting standards, and focusing on quality for AI proficiency. Emphasizing context, validation processes, and specialized agents for maximizing AI efficiency.

Excited for JS Nation in Amsterdam, emphasizing the importance of accessibility layers. Discussing the evolving systems and focusing on desktop accessibility journey. Introducing Tepiso Luhujo and discussing accessibility challenges in testing and browser relationships. Highlighting support for UI automation and IAccessible2 by JAWS and NVDA. Efforts like Accessibility Compact Data project aim to integrate accessibility info into tools seamlessly. Testing with virtual machines for accessibility, although tricky, can be worth it. Promoting empathy and fun in accessibility awareness sessions. Using multiple operating systems with respective screen readers for accessibility testing, recommending Playwright's accessibility plugin for automated testing.

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.

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+.

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.

Max Drake discusses the challenges and benefits of working with agents on the canvas using the TLDraw SDK. The conversation delves into the complexity of bringing LLMs to the canvas, emphasizing the need for significant engineering work. The discussion covers projects like Teach and fairies, highlighting collaborative agent dynamics and multi-agent collaboration. Utilizing coding agents for project management and enhancing project visualization with features like the tech tree are explored. Customization options in the Teal Draw SDK, token management, and optimization strategies for efficient data retrieval are also discussed.

The speaker delves into code editor development, emphasizing collaboration between humans and AI. Discussions revolve around adapting to technological changes while facing persistent cognitive limitations. Balancing cognitive load in software development is crucial for optimal task completion. Focus and alignment in software development are essential for effective problem-solving. Addressing challenges of team alignment in AI-driven environments is crucial to avoid creating legacy code bases. Pair programming enhances collaboration, accountability, and learning within development teams. Valuing collaboration, trust, and autonomy fosters speed and efficiency in software development. Leadership strategies focus on promoting autonomy, mastery, and purpose while addressing burnout. AI impact on productivity and collaborative coding practices are reflected upon, emphasizing the benefits of pair programming. Effective onboarding and encouraging pair programming adoption contribute to better problem-solving and team collaboration.

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.

AI dashboard utilization challenges include lack of clear metrics for effectiveness and low adoption rates. Companies struggle with AI implementation leading to delivery improvements and financial gains. AI transformation hurdles stem from a focus on fluency over workflow redesign. Achieving true AI integration requires deep integration for transformative change. Organizational challenges in AI involve balancing code production with product outcomes. Key steps for AI transformation include measuring real changes in production and prioritizing killing ineffective pilots. Managing cloud costs and addressing unused resources are key concerns. Measuring AI impact on teams, business, people growth, and skill development is crucial for successful implementation.

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.

Shifra, founding developer relations engineer at Render. Render is the cloud for builders. How to relate to users who are not people? Company growth challenges with AI recommendations affecting signups. The challenges of AI recommendations in contrast to traditional SEO. Impact on team operations and product development. Need for a strategic shift towards agent-centered developer experience. Developing interface design for agents, content portfolio importance, and human gate validation. The evolving role of agents in product consumption and the necessity for a fundamental shift in development focus. Facing challenges head-on, emphasizing agentic experience, and prioritizing system self-correction for productive agent and human interactions at Render.

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.

Eddie from PayPal introduces a game called Whack-A-Mole but discusses the importance of real-time data and its elimination of constant page refreshing for applications. The evolution from AJAX to Comet to WebSockets marked a transition towards efficient bidirectional data communication, with Socket.IO simplifying complex processes. Postgres changes and Superbase enhance real-time features for better user experience. Real-time event handling, presence tracking, and broadcast events are crucial for scalable and flexible processing. The talk also delves into challenges and solutions in handling real-time data, including managing presence metrics and monitoring event handling.

The talk focuses on how Sentry enables efficient shipping by building a design system with consistent components and setting coding constraints. TypeScript helps in understanding code impact and maintaining code hygiene. KNIP tool aids in detecting and removing unused code efficiently. Continuous code cleanup is facilitated by KNIP, enhancing code maintenance. KNIP helps in optimizing code utilization, handling challenges, and automating code review. Extending KNIP analysis, cross-file analysis with TypeScript and ESLint, false negatives in KNIB configuration, and tree shaking impact of bundlers are discussed.

The talk explores scaling AI adoption in a large engineering company, emphasizing mindset shifts and upscaling. It discusses achieving AI-native team transformation through AI fluency and standardization. The importance of upskilling individuals and teams, overcoming resistance, and addressing objections to AI tools is highlighted. Transitioning to AI-native engineering focuses on intent, teamwork, and problem-solving. Emphasizing co-learning, project context, and verification in AI engineering and engaging engineers in practical AI projects are key points. Exploring AI engineering fundamentals, optimizing project iterations, and addressing project bottlenecks are also discussed.

Eddie from PayPal introduces a Whack-A-Mole game to discuss real-time data and engage the audience. Real-time data is essential for dynamic updates and efficient data handling. Challenges with AI-generated MVP led to a successful times three model with real-time features. The evolution of data communication technologies from Comet to WebSockets is highlighted. Transition to WebSocket native implementation for efficiency and benefits of using Superbase are discussed. Real-time features in games, event handling, presence tracking, and event broadcasting are explored. React SDK, real-time tools, scalability with Meteor, and managing data noise are addressed in the Q&A sessions.