Когда-то давно разработчик открывал IDE, пил кофе, писал код, ругался на NullPointerException, снова пил кофе и шел фиксить прод.

Сейчас разработчик открывает IDE, а рядом уже сидит цифровой коллега, который:

  • предлагает архитектуру,
  • пишет код,
  • сам делает рефакторинг,
  • запускает тесты,
  • чинит линтер,
  • иногда даже объясняет почему оно не работает лучше, чем тот человек, который это писал.

И вот тут начинается самое интересное.

Мы тихо переехали из эпохи “AI-подсказок” в эпоху Agentic Coding.
То есть в мир, где нейросеть - уже не autocomplete на стероидах, а полноценный агент, который умеет выполнять задачи почти как инженер.

Почти.

Потому что если дать агенту слишком много свободы - через 15 минут у тебя:

  • удален production namespace,
  • переписан .env,
  • обновлены зависимости до несовместимых версий,
  • а в комментарии к Pull Request написано: “Improved overall architecture.”

Спасибо блин! Очень помог.

Что вообще такое Agentic Coding

Если коротко - это подход, при котором AI не просто дописывает строчки кода, а:

  1. Понимает задачу.
  2. Планирует действия.
  3. Анализирует проект.
  4. Меняет несколько файлов.
  5. Запускает проверки.
  6. Исправляет ошибки.
  7. Повторяет цикл.

То есть работает как маленький инженер внутри IDE.

Раньше AI выглядел так:

pri

IDE:

print()

Теперь AI выглядит так:

- “Я заметил, что у вас отсутствует retry-механизм для Redis, нет circuit breaker, а Dockerfile можно уменьшить на 300 MB. Я уже подготовил Pull Request.”

И ты сидишь такой: “Брат… я просто хотел endpoint добавить.”

Почему это вообще стало возможно

Все уперлось в три вещи:

1. Огромные контекстные окна

Современные модели умеют держать в памяти:

  • целые репозитории,
  • документацию,
  • миграции,
  • логи,
  • историю чатов,
  • архитектурные паттерны.

То есть AI больше не видит “одну функцию”.
Он видит систему.

А это уже очень опасный уровень магии.

2. Tool Calling

Модель теперь умеет:

  • читать файлы,
  • запускать команды,
  • выполнять тесты,
  • ходить в Git,
  • работать с терминалом,
  • обращаться к API.

То есть нейросеть перестала быть “чатиком”. Она получила руки.

3. Циклическое мышление

Современные AI-агенты умеют:

-> Понял задачу
-> Выполнил
-> Проверил
-> Нашел ошибку
-> Исправил
-> Проверил еще раз

Именно это превращает AI из “подсказчика” в “агента”.

Cursor - IDE, которая подозрительно хорошо понимает твой проект

Cursor - пожалуй, главный популяризатор Agentic Coding среди разработчиков.

Изначально многие воспринимали Cursor как:

“Ну VS Code, но с AI.”

А потом люди начали давать ему команды уровня:

“Сделай полноценную RBAC-систему с JWT, refresh token, middleware и миграциями.”

И эта штука реально начинала работать.

Чем Cursor хорош

Он понимает проект целиком

Cursor умеет:

  • индексировать репозиторий,
  • учитывать связи файлов,
  • понимать структуру приложения,
  • анализировать импорты и зависимости.

Это уже не “умный autocomplete”. Это junior+/middle инженер, который не спит и не просит повышение.

Cursor Agent Mode

Вот тут начинается настоящая магия.

Ты пишешь:

Добавь rate limit для FastAPI через Redis.

Cursor:

  • найдет нужные файлы,
  • добавит middleware,
  • обновит зависимости,
  • поправит Docker,
  • обновит конфиги,
  • иногда даже README.

И вот в этот момент становится слегка страшно.

Но есть нюанс

Если не ограничивать AI - он начинает “улучшать”.

А AI очень любит улучшать.

Ты просил:

Добавь healthcheck

AI через 20 минут:

  • обновил весь Kubernetes-манифест,
  • заменил logging stack,
  • вынес конфиги,
  • оптимизировал Docker layers,
  • переписал половину проекта на async.

Поэтому главный навык новой эпохи: уметь правильно ограничивать агента.

Claude - AI, который слишком хорошо читает код

Anthropic со своим Claude очень сильно зашел в инженерную среду.

Особенно:

  • backend,
  • DevOps,
  • инфраструктура,
  • security,
  • архитектура.

Потому что Claude очень хорошо:

  • читает большие объемы кода,
  • держит длинный контекст,
  • понимает документацию,
  • объясняет сложные системы.

Где Claude особенно хорош

1. Рефакторинг

Claude отлично:

  • декомпозирует монолит,
  • выносит абстракции,
  • приводит код к одному стилю,
  • объясняет архитектурные проблемы.

Иногда слишком активно.

Ты открываешь diff:

- 15 changed files
+ 287 changed files

И комментарий:

“I improved maintainability.”

Ну спасибо, теперь maintainability действительно улучшилась.
Никто просто больше не понимает как это работает.

2. Работа с инфраструктурой

Claude очень хорош в:

  • Kubernetes,
  • Terraform,
  • Ansible,
  • CI/CD,
  • Docker,
  • Helm.

Особенно когда нужно:

  • анализировать YAML,
  • искать проблемы,
  • объяснять race condition,
  • искать ошибки в GitOps.

3. Объяснение legacy

Это вообще отдельная суперсила.

Можно дать кусок древнего Bash:

cat users.txt | awk '{print $1}' | sed 's/root/admin/g'

И Claude спокойно объяснит:

  • что делает код,
  • где риски,
  • как переписать нормально,
  • почему автору этого скрипта в 2012 году было очень тяжело жить.

Codex - дедушка AI-разработки

OpenAI и их Codex - это вообще историческая штука.

Когда-то именно Codex показал миру:

“Нейросеть может писать код не как игрушка, а как инструмент.”

Именно оттуда выросли:

  • GitHub Copilot,
  • AI IDE,
  • современные coding agents.

GitHub Copilot - AI, который поселился в каждом втором VS Code

GitHub + OpenAI сделали то, что изменило рынок.

Copilot хорош тем, что:

  • максимально встроен в workflow,
  • не требует переучивания,
  • работает быстро,
  • помогает “не отвлекаться”.

Но Copilot - это скорее augmentation, чем agent

Он:

  • отлично дописывает код,
  • знает шаблоны,
  • помогает писать boilerplate.

Но полноценный Agentic Coding - это уже:

  • Cursor,
  • Claude Code,
  • OpenAI Codex CLI,
  • Devin-like системы,
  • AI orchestration.

Claude Code - терминал, который начал думать

И вот это уже реально новая эпоха.

Claude Code - это когда AI сидит прямо в терминале.

Он может:

  • читать проект,
  • запускать команды,
  • менять файлы,
  • анализировать ошибки,
  • чинить тесты.

Ты буквально говоришь:

fix failing tests

И дальше начинается инженерная мистика.

Самое опасное в Agentic CLI

AI получает доступ к:

  • shell,
  • git,
  • package manager,
  • docker,
  • kubectl.

А значит:

“rm -rf” теперь может прийти не только от уставшего админа в 3 ночи.

GigaChat и GigaIDE - российский AI тоже подтягивается

Сбер активно двигает тему AI-разработки через:

  • GigaChat
  • GigaIDE

И если честно - многие зря относятся к этому скептически.

Где GigaChat реально полезен

Особенно:

  • в корпоративной среде,
  • в закрытых контурах,
  • в российских инфраструктурах,
  • там где нельзя отправлять код наружу.

Это очень важный момент.

Потому что половина enterprise сейчас сидит с мыслью:

“AI - это круто, но наш исходный код в интернет не поедет.”

И вот тут локальные или on-premise решения становятся очень интересными.

GigaIDE

По сути это попытка сделать:

  • AI-assisted IDE,
  • генерацию кода,
  • помощь разработчику,
  • локальную AI-интеграцию.

Да, пока это не Cursor-уровень по ecosystem и качеству агентности.
Но направление очень правильное.

Особенно для:

  • банков,
  • госструктур,
  • внутренней разработки,
  • закрытых инфраструктур.

Главная проблема Agentic Coding

И нет, это не hallucinations.

Главная проблема:

люди начинают отключать мозг.

AI пишет уверенно.
Очень уверенно.

Даже когда творит полную дичь.

Самая опасная фраза 2026 года

Looks good to me

Потому что:

  • AI написал код,
  • AI прогнал тесты,
  • AI проверил линтер,
  • AI сделал PR,
  • AI сам себе поставил approve.

А потом production ложится так красиво, что Grafana начинает выглядеть как кардиограмма человека после тройного эспрессо.

Что AI уже умеет реально хорошо

Отлично умеет

  • boilerplate,
  • CRUD,
  • документацию,
  • тесты,
  • рефакторинг,
  • Terraform,
  • YAML,
  • Kubernetes,
  • SQL,
  • миграции,
  • REST API,
  • SDK,
  • интеграции,
  • поиск багов,
  • объяснение legacy-кода.

Пока плохо умеет

  • сложную архитектуру,
  • бизнес-контекст,
  • компромиссы,
  • production thinking,
  • безопасность на глубоком уровне,
  • performance engineering,
  • распределенные системы.

AI может написать Kafka consumer.

Но:

  • почему у тебя случится rebalance storm,
  • почему Ceph внезапно решил умереть,
  • почему Patroni ушел в split-brain,
  • почему etcd начал страдать - это все еще обычно выясняет человек с красными глазами и кружкой холодного кофе.

Как выглядит хороший инженер в эпоху Agentic Coding

Раньше ценился человек:

  • который быстро писал код.

Теперь ценится человек:

  • который умеет управлять AI-агентами,
  • понимать архитектуру,
  • валидировать изменения,
  • задавать правильные ограничения,
  • видеть риски.

То есть инженер постепенно превращается:

  • из “исполнителя”
  • в “оркестратора”.

И если честно - это довольно логичная эволюция.

Практические советы

1. Никогда не давай агенту полный доступ без sandbox

Иначе:

kubectl delete namespace production

может стать частью “автоматической оптимизации”.

2. Ограничивай scope

Плохо:

Improve project

Хорошо:

Добавь retry для Redis в файле cache.py без изменения API.

3. AI отлично пишет новое - плохо понимает старое

Legacy-код:

  • старые зависимости,
  • hidden side effects,
  • магия из 2014 года - это все ломает даже хорошие модели.

4. Всегда читай diff

ВСЕГДА.

Даже если AI выглядит уверенным.

Особенно если AI выглядит уверенным.

Что будет дальше

Скорее всего:

  • IDE превратятся в AI orchestration platform,
  • появятся multi-agent системы,
  • AI будет сам ходить в Jira,
  • сам чинить баги,
  • сам открывать PR,
  • сам деплоить preview environments.

А инженер будет:

  • задавать направление,
  • принимать архитектурные решения,
  • контролировать риски.

Ну и иногда ночью смотреть:

git diff

с выражением лица:

“Кто опять дал агенту доступ к production…”