Frontend в 2026. Rust снизу, AI сверху, а мы на вертеле межу ними

Браузер представляет всё больше api, инструменты переезжают на Rust и Go, а AI берёт на себя ручную работу. Что остаётся frontend-разработчику посередине и почему понимание системы становится важнее скорости написания компонентов

Frontend-разработчик с ноутбуком между слоем браузера и native tooling снизу и сетью AI-агентов сверху

роль ai сыграла моя Шебайган

Лирическое вступление и вопрос

Во-первых я благодарен Роме Троицкому за его пет-проект Frontend status который помогал мне в течении всего года держать руку на пульсе и знать что в мире происходит. Также несметное количество конференций которые говорили про одно и тоже ртами разных спикеров

На фоне всего происходящего я стал чаще думать о собственном пути и вдруг осознал: у меня идёт десятый год с React. Как-то я уже писал, что долго искал своё направление - дело, которое мне отзовётся и в котором захочется остаться надолго. Сначала нашёл интерфейсы. Потом искал подходящий инструмент. С Angular впервые возникло чувство "вот оно". А с React случилась любовь

И тут я заметил, что в важных для меня историях почему-то повторяется число 11. Футболом я занимался 11 лет. Музыкой занимаюсь уже 22

Есть и ещё одна история. Детский сад. Дневной сон. Все спят, а я не могу. Девочка, чья кровать стоит впереди, отпрашивается в туалет. Я поворачиваю голову и смотрю, как она встаёт. Самый обычный момент, который почему-то помню до сих пор. Кристина Кокорева. Я тогда ещё не понимал, что это за чувства и почему из всех людей в комнате мне хочется смотреть именно на неё. Ровно через 11 лет мы с ней ответили на этот вопрос

Наверное, никакой закономерности здесь нет. Просто мой мозг любит находить рифмы в собственной биографии. Особенно когда настоящее начинает меняться быстрее, чем ты успеваешь к нему привыкнуть

Через год нашим отношениям с React тоже исполнится 11 лет. Интересно, станет ли этот год последним? Или, как с музыкой, я просто продлю подписку, но уже на немного других условиях

Погнали

Год ещё не закончился, но некоторые итоги для себя я уже вижу и выглядит всё довольно символично. За последние пятнадцать лет frontend показал, что JavaScript можно использовать вообще для всего

серверы
desktop-приложения
mobile
CLI
bundlers
compilers
build systems
инструменты для написания инструментов для сборки других инструментов

JavaScript победил

но к 2026 году массовый переезд инструментов для JavaScript на Rust и Go стал уже слишком заметным, чтобы его игнорировать

TypeScript вспомнил, что у компьютера несколько ядер

Одно из главных событий года - TypeScript 7, вышедший 8 июля.¹

Microsoft фактически переписала TypeScript compiler и language service на Go.

Команда TypeScript заявляет типичное ускорение полного type checking примерно в 8-12 раз. Сам релиз они называют "10x faster native port". В опубликованных примерах VS Code проверяется примерно за 10,6 секунды вместо 125,7, Sentry - за 15,7 вместо 139,8 секунды¹

Причина довольно прозаичная - native code, shared memory и многопоточность

Есть ощущение, что рынок dev-инструментов нащупал границы и теперь вместо фиче-гонок инструменты пошли в сторону скорости

Vite тоже уходит из JavaScript

В марте вышел Vite 8²

До этого внутри Vite существовала довольно прагматичная конструкция:

development → esbuild
production → Rollup

В Vite 8 её заменили единым Rolldown - bundler'ом на Rust.

Команда Vite пишет, что в бенчмарках Rolldown работает в 10-30 раз быстрее Rollup. На реальных проектах цифры спокойнее, но тоже заметные: например, Linear сообщал о сокращении production build с 46 до 6 секунд.²

При этом вокруг Rolldown строится целый стек:

Vite
  ↓
Rolldown
  ↓
Oxc

Parser
Resolver
Transformer
Minifier
Semantic analysis

Большая часть тяжёлой работы постепенно уезжает туда, где JavaScript уже не участвует. SWC давно написан на Rust. Oxc - Rust. Rolldown - Rust

Astro в этом году переписал свой .astro compiler с Go на Rust и перевёл Markdown/MDX pipeline на Rust. Вместе с Vite 8 и новым механизмом рендеринга это дало ускорение сборок на 15-61% в собственных benchmark'ах команды³

То есть картина становится довольно понятной. JavaScript остаётся прекрасным языком, чтобы писать приложение. Но индустрия всё меньше хочет использовать JavaScript, чтобы разбирать, компилировать и собирать этот JavaScript

React внезапно снова начал говорить с браузером

У React год тоже получился интересным. 9 сентября вышел React 19.3.⁴. Стабильными стали <ViewTransition> и Fragment Refs, появилась поддержка Trusted Types и ряд других API. Особенно интересны View Transitions. Исторически frontend развивался примерно так:

браузер предоставляет примитив
мы считаем его недостаточно удобным
пишем абстракцию
потом framework абстракцию
потом библиотеку вокруг framework абстракции

Через четыре года браузер предоставляет нормальный API. React 19.3 теперь непосредственно интегрируется с View Transition API браузера.

То есть transition

route A → route B

всё меньше требует отдельной системы анимаций и всё больше становится частью самой платформы. Есть и ещё одно событие, менее техническое, но, возможно, более важное в долгосрочной перспективе.

В феврале официально заработал React Foundation под Linux Foundation. React, React Native и JSX больше не принадлежат Meta - ими теперь владеет независимый фонд, среди founding members которого Meta, Microsoft, Amazon, Vercel, Expo и другие компании⁵. React постепенно превращается из технологии конкретной корпорации в инфраструктурный слой индустрии.

Angular незаметно стал совсем другим

На фоне React про Angular сегодня говорят заметно меньше. И зря. Angular 22 вышел 3 июня,⁶ и изменения последних версий постепенно превращают его в довольно другую систему

Signals
resource()
httpResource()
Signal Forms
Zoneless
OnPush теперь default change detection strategy

Signal Forms стабилизированы, Zoneless уже стал стабильным режимом по умолчанию, а в Angular 22 OnPush используется по умолчанию⁷

То есть старый Angular

Zone.js
RxJS everywhere
глобальный change detection
магия
ещё немного магии

медленно превращается в:

signals
explicit reactivity
fine-grained updates
compiler/runtime optimizations

При этом Angular ещё и отказался от выпуска major каждые полгода. Начиная с v22 major выходит раз в 12 месяцев, а поддержка major увеличена до двух лет.⁶. Angular взрослеет. Редкое заболевание среди frontend-framework'ов

Браузер мешает мне раздувать package.json

Но самый недооценённый frontend-framework сегодня, возможно, называется Chrome/Safari/Firefox. Пока мы последние десять лет расширяли package.json, платформа тоже не стояла на месте

Только в Baseline 2026, то есть в набор возможностей, ставших доступными в основных браузерах в этом году, вошли:⁸

field-sizing
container style queries
@scope
:open
contrast-color()
Custom Highlights
WebTransport
Trusted Types
Navigation API

и другие возможности

Например, autoresize textarea теперь всё чаще выглядит так

textarea {
  field-sizing: content;
}

И всё. Никакого observer. Никакого React hook. Никакого useAutoResizeTextarea.ts. Никакого npm package с 14 миллионами downloads, последний commit которого сделал студент из Польши в 2019 году. Просто CSS.

Для frontend-разработчика это немного тревожная тенденция. Потому что если задача решается одной строкой CSS, вокруг неё сложно построить архитектуру. Сложно, но не невозможно. Хватает умельцев

Тем не менее фундаментальная тенденция здесь очевидная - всё больше возможностей постепенно спускается вниз

application
↓
framework
↓
browser

И код приложения становится меньше. А значит больше времени останется на мысли о высоком - о годовой премии. В оставшееся время мы подумаем о продукте

Next.js пытается сделать сервер незаметным

Отдельная линия эволюции происходит вокруг Next.js. Server Components сделали React-приложение архитектурно гораздо сильнее завязанным на сервер. Но появился очевидный UX-конфликт. Пользователь совершенно не обязан понимать, насколько красиво мы организовали streaming. Он нажал кнопку. Он хочет, чтобы интерфейс отреагировал сейчас.

Next.js 16.3 поэтому сильно сфокусирован на Instant Navigations: framework пытается сохранить server-first архитектуру, но вернуть ощущение мгновенной SPA-навигации. Shell страницы может быть доступен сразу, динамический контент приезжает позже через streaming/cache. Сам релиз также заметно уменьшил использование памяти в dev и продолжил развитие Turbopack⁹

По сути сейчас идёт интересный цикл

сначала мы строили SPA, потому что server-rendered navigation ощущалась медленной
потом вернули сервер, потому что SPA стали слишком тяжёлыми
теперь делаем серверные приложения, которые должны ощущаться как SPA

Ещё несколько итераций - и мы начнем клепать вебсайты

блин, я же реально клепальщик сайтов

Но самая важная новость года вообще не про framework

Самое существенное изменение frontend 2026 года, на мой взгляд, выглядит иначе. У dev-тулзов появился второй пользователь... ой а кто это?

Раньше инфра проектировалась для человека

developer
    ↓
IDE
    ↓
CLI
    ↓
framework

Теперь появляется ещё одна ветка...

AI agent
    ↓
tooling
    ↓
framework
    ↓
codebase

И если смотреть на релизы этого года под этим углом, изменения внезапно начинают складываться в одну картину.

Next.js 16.3 автоматически поддерживает в AGENTS.md указатель на документацию конкретной версии framework. Рядом развиваются first-party Skills, Agent Browser с React introspection, диагностика с подсказками для агентов и более компактный MCP server¹⁰. Astro 7 научился определять coding agents, автоматически запускать dev server в background mode и отдавать structured JSON logs.³

Причина прекрасна. Обычный console output оптимизирован для человека

цвета
рамочки
многострочный stack trace
ASCII-art

Для машины всё это просто декоративный мусор

Поэтому Astro теперь может говорить:

astro dev --json

и выдавать данные в форме, которую нормально понимают инструменты. Nx пошёл ещё дальше. В roadmap компании прямо написано

2026 is the year Nx becomes infrastructure for autonomous AI agents.¹¹

В Nx 23 появились agentic migrations. В гибридном варианте обычный codemod делает детерминированную часть миграции, а агент разбирается со специфическими зависимостями, конфигами и архитектурой конкретного проекта.¹² И вот это уже действительно интересно. Жаль никто из разрабов вокруг меня никто про это не знает. Буду и дальше на проекте сидеть молчать про эту мегафичу

AI меняет интерфейс разработки

Первый этап AI в программировании выглядел примерно так

- напиши функцию сортировки массива

Потом

- добавь мне CRUD

Потом

- посмотри этот репозиторий и исправь задачу

Следующий этап

- измени систему

А для этого уже недостаточно умения хорошо генерировать TypeScript. Агенту нужно понимать

архитектуру
dependency graph
контракты
логи
CI
runtime
browser state
ошибки
правила проекта
историю изменений

То есть AI постепенно переходит от code generation к software operation. И вместе с этим меняются сами инструменты. Человеку можно показать:

Something went wrong

Человек тяжело вздохнёт. Попьёт кофийку. Потом поход туалет. Потом покурить. Открыть ноут. Stack trace смотрет. Гуглит. GitHub issue 2019 года найдит. Поставит --legacy-peer-deps. И проблема каким-то мистическим образом исчезнет. Агент с таким интерфейсом работает плохо

Ему нужны:

error code
structured context
dependency graph
schema
machine-readable logs
deterministic commands
tests
health endpoints

Есть в этом довольно красивая ирония. Возможно, именно AI наконец заставит developer tooling иметь нормальные интерфейсы. Не потому что человеку стало удобнее. Просто машине неудобно

Что теперь делает frontend-разработчик

И здесь возникает вопрос

если AI умеет писать компоненты
если AI умеет писать тесты
если AI умеет делать миграции
если браузер сам умеет всё больше
если compiler автоматически оптимизирует код
если design system уже существует

То что остаётся frontend-разработчику? Ответ, на мой взгляд, неприятный для junior-level задач и довольно хороший для профессии в целом. FE всё меньше нужен как производитель строк кода. Но всё больше нужен как человек, который понимает систему. Потому что создать

<Button onClick={handleSubmit}>
  Save
</Button>

уже давно не самая сложная часть разработки

Сложнее понять

Почему эта кнопка вообще существует?
Что произойдёт после клика?
Где проходит граница server/client?
Как выглядит optimistic update?
Можно ли восстановить состояние?
Что происходит при повторном запросе?
Какая accessibility semantics?
Как это измеряется?
Что увидит пользователь при partial failure?
Как поведёт себя приложение на медленной сети?
Как эта фича существует внутри общего UI-kit?
И что произойдёт, когда AI за один PR изменит двадцать семь файлов вокруг неё?

То есть ценность постепенно смещается

писать implementation
        ↓
проектировать систему
        ↓
задавать ограничения
        ↓
проверять результат

Frontend-разработчик становится немного меньше кодером и немного больше

архитектором
product engineer
интегратором
ревьюером
оператором AI-систем.

Самое смешное, что senior-разработчики много лет говорили

главное - не код, а умение принимать инженерные решения

вот эти вот разговоры у кулера, после которых умельцы удалялись клепать legacy. Но вот пришла машина и начала превращать этот тезис в реальность

Есть ещё одна неприятная сторона

Чем больше framework делает за нас, тем тяжелее становится framework. И тем дороже ошибка внутри него.

В 2026 Next.js уже перешёл на регулярный security release process ¹³. Только августовский релиз закрыл две критические зависимости,¹⁴ а 22 сентября вышел ещё один экстренный critical update.¹⁵

На момент написания статьи (27 сентября) на 30 сентября запланирован пакет ещё из девяти исправлений, включая одну критическую зависимость ¹⁶

Естественное следование того, что современный frontend framework - это уже давно не библиотека рендера. Это

server runtime
router
cache
compiler
bundler integration
RPC-like boundary
streaming
serialization
deployment abstraction

То есть поверхность атки растёт вместе с возможностями инструмента

И поэтому ещё один тренд ближайших лет выглядит почти гарантированным: гигиена зависимостей, автоматические обновления станут частью обычной frontend-разработки особенно когда эти зависимости начнут массово менять AI-агенты

Куда всё это движется

Получается довольно интересное движение с двух сторон

Снизу frontend съедает Web Platform

CSS
Browser APIs
Navigation
View Transitions
native controls

Чуть выше инфраструктуру забирает native tooling

Rust
Go
Oxc
Rolldown
SWC
native TypeScript

Сверху implementation начинает забирать AI

code generation
tests
migrations
refactoring
debugging
CI repair

А человек остаётся где-то в середине

        AI agents
            ↓
   implementation
            ↓
 ┌───────────────────┐
 │   FE engineer     │
 │ architecture      │
 │ constraints       │
 │ product thinking  │
 │ verification      │
 └───────────────────┘
            ↓
 framework / runtime
            ↓
 native tooling
            ↓
     Web Platform

Мне кажется, это и есть главный тренд.

Frontend не исчезает. Из него вымывается ручная работа

А что любит любой разраб больше всего? Да - работать руками (писать код)

Следующий frontend будет менее frontend

Я бы ожидал несколько продолжений этого движения.

во-первых, ещё больше tooling переедет в Rust/Go/native. Не потому что JavaScript плохой. А потому что compiler, parser или bundler - это инфраструктурная задача, и здесь latency и parallelism имеют огромное значение
во-вторых, всё больше библиотек станет ненужными благодаря Web Platform. Особенно небольшие библиотеки вокруг layout, navigation, animation, form controls и browser state. АРХИТИКТУУУУУРААААА
в-третьих, появилось понятие agent DX рядом с developer DX. Framework без machine-readable errors, документации для LLM, introspection и стабильных CLI/API постепенно станет таким же неудобным, каким сегодня выглядит сайт без mobile layout. Но тут смотря какой fabric
в-четвёртых, тесты станут ещё важнее. Парадоксально, но чем больше кода будет писать AI, тем ценнее становится автоматическая проверка. Потому что человеческое ревью плохо масштабируется против машины, способной изменить сто файлов за несколько минут.
в-пятых, архитектурные ограничения будут всё чаще описываться в форме, которую может прочитать не только разработчик.

Сегодня это

AGENTS.md.
MCP
lint rules
schemas
dependency constraints
architecture tests

Сейчас я уже вижу как это становится отдельным полноценным слоем проекта. И наконец, monorepo может неожиданно получить вторую жизнь. Раньше его главный плюс был в организации человеческих команд и shared code. Теперь появляется ещё один

агенту гораздо проще принимать изменение, когда он видит систему целиком

Frontend, backend, schemas, tests, design system и инфраструктура в одном dependency graph становятся контекстом для машины

Итого

Если несколько лет назад frontend развивался прежде всего горизонтально - больше framework'ов, библиотек, способов управлять состоянием - то сейчас движение стало вертикальным

Вниз

ближе к платформе
ближе к браузеру
ближе к native performance
ближе к пособию по безработице

Вверх

к продукту
к архитектуре
к AI orchestration

И возможно, самая важная компетенция frontend-разработчика следующих нескольких лет будет звучать довольно скучно - понимать систему целиком. Понимать, какие части системы вообще должны существовать, какие не должны, где проходят её границы и как доказать, что она работает правильно. Потому что написать код становится всё дешевле. Ошибиться в том, какой код нужно было написать, - пока нет. Мы двадцать лет строили огромный слой сложности между человеком и браузером. Теперь браузер ест его снизу. AI - сверху. А мы пока сидим посередине. Высокотехнологический double penetration вертел. Тепло и приятно

Лирическое вступление и вопрос​

Погнали​

TypeScript вспомнил, что у компьютера несколько ядер​

Vite тоже уходит из JavaScript​

React внезапно снова начал говорить с браузером​

Angular незаметно стал совсем другим​

Браузер мешает мне раздувать package.json​

Next.js пытается сделать сервер незаметным​

Но самая важная новость года вообще не про framework​

AI меняет интерфейс разработки​

Что теперь делает frontend-разработчик​

Есть ещё одна неприятная сторона​

Куда всё это движется​

Следующий frontend будет менее frontend​

Итого​

Footnotes​