ITNEWS.pro
…
7 ноября 2026 в 07:33
Подписаться
AI убивает классическую карьерную лестницу в IT

В IT долгое время существовала вполне понятная модель профессионального роста. Компания нанимала Junior-разработчика, давала ему несложные задачи, постепенно знакомила с кодовой базой и внутренними процессами. Он исправлял баги, писал небольшие API, покрывал код тестами, разбирался с интеграциями. Рядом работали Middle и Senior, которые проверяли решения, объясняли архитектурные ограничения и не давали новичку случайно превратить сервис в распределённую систему случайных эффектов.

Через несколько лет такой разработчик сам становился Middle, а затем, если хватало опыта и инженерного мышления, Senior. Компания получала специалиста, которого в значительной степени вырастила собственными силами.

Эта модель никогда не была идеальной. В одних командах Junior годами перекладывал JSON из одного DTO в другой, в других действительно учился проектировать системы. Но экономическая логика была понятной: часть работы можно поручить менее опытным сотрудникам, а их развитие со временем окупится.

AI-инструменты начали менять именно эту экономику.

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

Для менеджмента вывод выглядит соблазнительно: зачем нанимать Junior, если текущая команда с AI справляется с большим объёмом работы?

На короткой дистанции решение кажется рациональным. Меньше затрат на найм, адаптацию и ревью. Меньше времени у Senior уходит на объяснение базовых вещей. Выше пропускная способность команды.

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


Код можно сгенерировать. Инженерный опыт - нет

Главная ловушка AI-разработки — путать способность получить работающий фрагмент кода со способностью отвечать за систему, в которую этот код попадёт.

Модель может предложить конфигурацию Kafka, написать consumer и даже добавить обработку ошибок. Но она не знает всех особенностей конкретного production-контура, если эти особенности не описаны в доступном ей контексте. Она не несёт ответственности за последствия повторной доставки сообщений, некорректной обработки offset или изменения порядка событий.

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

Та же история с Redis. AI быстро напишет кеширование и предложит TTL. Но выбор стратегии инвалидации зависит от характера данных, допустимой устарелости, нагрузки на базу и поведения приложения при массовом истечении ключей. Неправильное решение может превратить кеш в дополнительный источник проблем, а не в способ разгрузить систему.

С Kubernetes ситуация ещё интереснее. Сгенерировать Deployment, Service и HPA несложно. Понимать, почему поды постоянно перезапускаются, как requests и limits влияют на планирование, откуда берётся throttling и почему autoscaling не спасает при определённом профиле нагрузки, — уже совсем другая работа.

Это знание редко появляется после чтения документации. Оно формируется через ошибки, инциденты, неудачные релизы, разбор метрик и неприятные разговоры о том, почему сервис снова лежит в пятницу вечером.

Именно здесь возникает принципиальный разрыв. AI снижает стоимость получения первого решения. Он не отменяет стоимость проверки этого решения в реальной системе. Более того, чем проще становится генерировать код, тем больше потенциальных изменений может попасть в систему без достаточного инженерного контроля.

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


Найм перестаёт проверять скорость написания кода

Традиционное техническое интервью уже давно не идеально отражает реальную работу разработчика. Но с распространением AI его слабые места стали особенно заметны.

Попросить кандидата реализовать алгоритм на доске или написать небольшой сервис за ограниченное время — не лучший способ оценить его эффективность в современной команде. В повседневной работе разработчик использует документацию, поиск, IDE, тесты, внутренние библиотеки и AI-ассистентов. Запретить всё это на интервью — значит искусственно создать условия, в которых человек работает не так, как будет работать после выхода на проект.

При этом разрешить AI и оценивать только итоговый код тоже бессмысленно. Модель может написать вполне приличную реализацию за несколько минут. Это ещё ничего не говорит о том, насколько кандидат понимает её устройство.

Гораздо показательнее дать человеку незнакомую кодовую базу или небольшой существующий сервис с несколькими проблемами. Пусть он использует привычные инструменты, включая AI. Важен не сам факт обращения к модели, а то, как кандидат работает с её предложениями. Замечает ли противоречия в архитектуре, проверяет ли предположения, понимает ли последствия изменений? Может ли объяснить, почему выбрал конкретный вариант и от каких альтернатив отказался?

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

Для Middle+ и Senior всё большее значение приобретает способность управлять процессом разработки целиком. Разобраться в требованиях, сформулировать техническое решение, использовать AI для ускорения реализации, проверить результат и довести изменение до production.

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


Почему CTO могут оптимизировать не ту часть разработки?

У AI есть очевидное преимущество: он сокращает время между постановкой задачи и появлением первого варианта реализации. Но этот участок не всегда определяет скорость поставки продукта.

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

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

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

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

Гораздо полезнее смотреть на полный цикл: сколько времени проходит от начала работы до production, как часто релизы приводят к проблемам, сколько занимает восстановление после инцидентов, насколько дорого обходится сопровождение изменений. Если AI ускорил написание кода, но выросли объём переделок и стоимость поддержки, команда не стала эффективнее. Она просто быстрее производит обязательства, которые потом придётся выполнять.

Поэтому внедрение AI должно начинаться не с вопроса о том, сколько разработчиков можно заменить, а с понимания того, где именно команда теряет время и почему. Иногда проблема действительно в реализации. Иногда — в архитектуре, процессах, качестве требований или инфраструктуре. И никакая модель не исправит организационный хаос одним удачным промптом.


Новая карьерная лестница: меньше механической работы, выше цена контекста

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

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

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

Параллельно формируются новые специализации. Инженеры работают с LLM-инфраструктурой, RAG-системами, агентными архитектурами, оценкой качества моделей, inference-оптимизацией и LLMOps. Здесь тоже недостаточно просто подключить API модели. Нужно понимать стоимость запросов, задержки, качество retrieval, ограничения контекстного окна, защиту от prompt injection, воспроизводимость результатов и поведение системы при отказах внешних компонентов.

При этом не стоит ожидать, что каждый разработчик обязан срочно стать специалистом по LLM. Для многих команд важнее научиться грамотно применять AI в обычной инженерной работе. Но планка ожиданий действительно меняется: от специалиста всё чаще ждут, что он сможет самостоятельно пройти путь от неоднозначной задачи до надёжного production-решения.

Возникает парадокс. Чем больше работы можно делегировать модели, тем важнее становится способность определить, что именно ей можно делегировать. Это требует опыта, технического кругозора и понимания цены ошибки.

В результате Senior, который умеет использовать AI, может стать значительно продуктивнее. Но человек, который только научился генерировать код, не получает автоматически компетенции Senior. Между этими состояниями остаётся тот же объём инженерной ответственности - просто теперь его сложнее скрыть за количеством написанных строк.


Кто же будет выращивать новых инженеров?

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

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

Разработчику стоит использовать модели для исследования кодовой базы, генерации тестов, сравнения подходов и ускорения рутинной работы. Но полезно сохранять за собой сложные части процесса: формулировку проблемы, выбор архитектуры, проверку гипотез и анализ последствий. Иначе можно быстро привыкнуть получать готовые решения, постепенно теряя способность самостоятельно оценивать их качество.

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

Это не призыв вернуть практику бессмысленного перекладывания JSON ради стажировки. Учебные задачи должны быть связаны с реальными системами и постепенно увеличивать ответственность. Новичку полезно разбирать инциденты, участвовать в ревью, исследовать поведение сервисов под нагрузкой, исправлять дефекты и видеть последствия собственных решений. AI может помогать на каждом этапе, но наставник должен объяснять контекст и учить оценивать результат.

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


Главный риск - не автоматизация, а разрыв преемственности

AI действительно меняет разработку. Он сокращает время реализации, снижает порог входа в новые технологии и позволяет небольшим командам делать то, для чего раньше требовалось больше ресурсов. Игнорировать это бессмысленно.

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

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

Классическая карьерная лестница действительно меняется. Некоторые её ступени теряют экономический смысл, другие становятся короче, а требования к самостоятельности растут. Но потребность в инженерном опыте никуда не исчезает.

Вопрос теперь не в том, сможет ли AI писать код вместо Junior. Сможет - и уже умеет во многих типовых сценариях. Вопрос в том, кто будет формировать следующее поколение инженеров, если компании перестанут давать людям возможность учиться на настоящей разработке.

И это уже не проблема отдельного разработчика. Это стратегический риск для всей индустрии.


Подписывайся на наш Telegram и не пропусти главные новости!