Schedule

How we integrated external neural networks into our team.

Did you know that 80% of the state in your front-end projects is actually cache?

Maybe we’ve been doing it all wrong.

Application State, Local State, Server State - it’s time to set the record straight and learn how to handle each one properly.

Standard observability answers the question "what was executed." You know that traces and spans describe function calls, while errors involving "silent" bad data might — with varying degrees of success — be found in the logs.

Yet, truly convenient observability remains like a tempting desert oasis: always somewhere out there on the horizon. This talk will show you how to link execution context with data, making the journey to OpenTelemetry both useful and transparent. It all happens within the standard runtime — no V8 patches or other "street magic" required... though, naturally, there will be just a touch of it; after all, where would we be without that?

A series of short game tasks in constantly changing teams.

How to develop projects with Claude/Codex and not go crazy. In the talk, I will tell you about the important features of Claude and show you how to apply the SDD approach in practice.

The participant will leave with a mental and, for now, timeless model of "What the server doesn't know and why it won't find out" and criteria for choosing a strategy with an acceptable price.

In the modern frontend, a multitude of state managers have emerged, each solving business problems in their own way — so why create yet another state manager?

How to automate quality control and make the development process with agents more reliable and faster.

In this talk, we will explore why web testing often turns into a box-checking exercise, what teams mistakenly call end-to-end testing, and how to build a practical engineering approach to tests. The main focus will be on hands-on examples with functions, React hooks, and components, giving you techniques you can apply to real projects the very next day.

I want to highlight another perspective on UI that combines the purity of the functional paradigm with the reactivity of the reactive model: incremental computation. Let's explore this idea and its implementation in well-known JavaScript frameworks.

I'll tell you what has changed in React Compiler since the release a year ago, whether the bugs from the first release have been fixed, when you can stop using useMemo yourself, and what pitfalls you need to be aware of when using React Compiler to delegate the useMemo removal to a coding agent.

Dear reader, what will you choose: a final skill or a skill to create skills? Come to the interactive Skill workshop. Why interactive? Let's work together right in the hall.

Good architecture is not about deciding which folder a file belongs in. It is about deciding where to draw boundaries. We will examine a practical, transferable principle: place barriers where your control ends, and use real-world examples to understand when an abstraction pays for itself — and when it is just unnecessary overhead.

I’ll tell you how we built Agents Rules — a platform that stores, checks, and delivers OpenCode settings to working repositories, turning the findings of one team into ready‑made tools for others.

We'll try to figure out when micro frontends will help your app and when they'll complicate it unnecessarily.

This is a story about how we built a system that allows us to check the technical quality of 100+ repos and roll out mass changes on them.

Dear reader, what will you choose: a final skill or a skill to create skills? Come to the interactive Skill workshop. Why interactive? Let's work together right in the hall.

Let's discuss the requirements for the layout and ui-kit and configure the Figma MCP + agent combination so that the code is generated based on your components and passes your review.

The talk will consider the AG-UI protocol for building agent applications using the example of a bundle with LangGraph and Copilotkit.

Analytics, tracing, monitoring, devtools — they are all so different, but they do the same thing — log aggregation. Let's talk about how to unify all of this and make life easier for yourself, LLM, and your business.

We will figure out how testing differs from quality assurance, test the feature with our own hands, transfer the checks to the code, review autotests and requirements, and try to understand which quality metrics really make sense.

We'll train a local model in JS that looks at the rendered component and tells good markup from bad, then wire it into an MCP server that renders whatever the agent produced, runs it through the model, and returns not a vague "doesn't match the design" but a concrete score the agent can use to correct itself.

Interfaces without color theory are like JavaScript without algorithms.

The talk will guide developers from theory to practice, from generating the right shades to working with themes. It will introduce techniques that allow you to write more flexible color theory-based code right now.

You will see how familiar JavaScript ends up on a microcontroller and becomes a bridge between the real world and the AI agent.

Let's go through all the steps — from the code on the chip to the bundle with AI.

Let's create a search skill for an AI agent who can work with closed documentation, a corporate Wiki and other internal sources. Let's go from a naive prototype to a ready-made solution for a closed circuit, analyze the key technical solutions and see everything working in a live demonstration.

Let's explore how our beloved V8 works with code examples, see what happens to our code inside the engine, and discover what this TurboLion is and what it will bring us in the future!

I will tell you what the Language Server Protocol is, how the editor and language server interact, what tasks it solves, and how to write your own language server.

Game developers constantly complain that graphics and network interactions are the most difficult aspects of game development. Meanwhile, all we do on the web is send bytes over the network and paint pixels.

Are all game developers so mediocre? Or is there something we don't know about how deep the rabbit hole goes?

We will discuss the practical experience of a long-lived Schema Driven UI.

Why use ONNX on the client at all? Comparison of server-side inference and client-side inference: latency, cost, and data privacy. When is it justified and when is it an anti-pattern?

I will tell you how to reduce the pipeline build time to 97%, and also give you the main part of the source code of the solution, proving that good code can be written even in infrastructure scripts!

Large language models can generate convincing code, but they cannot reliably determine whether it actually works. In this talk, I will demonstrate two ways to give AI an engineering feedback loop: a formal specification based on types and category theory, and a runtime verification system in which generated code is instrumented, executed, inspected, and corrected before it reaches the user.

We will travel from Aristotle’s syllogisms and Church encodings to TypeScript, advanced prompting, and AI-agent architecture. Finally, I will share how I tested these approaches at Avito, including correctness metrics, iteration count, token usage, latency, cost, and the practical limitations of automated verification.

Let's look at the story of one team that went to a hackathon, where everyone chose a staff manager. And what came of it...

Untyped DI, try/catch, side effects, AbortSignals, reinvented wheels... TypeScript can do better.

Dear reader, what will you choose: a final skill or a skill to create skills? Come to the interactive Skill workshop. Why interactive? Let's work together right in the hall.