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

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

Мне стало интересно, какие качества в этой ситуации действительно отличают сильного разработчика. 

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

Мой собеседник — Денис Синюков, Full Stack инженер, архитектор приложений, специалист по корпоративным IT-системам, fintech-разработке и автоматизации бизнес-процессов с более чем 10-летним опытом. Мы поговорили о том, почему технических знаний становится недостаточно, какие ошибки в разработке оказываются самыми дорогими и за что компании будут готовы платить программистам в будущем.

Как меняется профессия разработчика

Вы работаете в IT более десяти лет. Как за это время изменилась сама профессия и требования к разработчикам?

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

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

В этом смысле профессия стала гораздо ближе к инженерии в широком понимании. 

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

Что сегодня отличает действительно сильного программиста от человека, который просто хорошо пишет код?

Сильный разработчик думает не только о своей конкретной задаче, но и о том, как работает все вокруг нее. Он задает неудобные вопросы: «А что произойдет, если это сломается?», «Зачем это вообще нужно бизнесу?», «Кто и как будет это поддерживать?». 

Он не боится зайти в чужой старый код без документации и попытаться понять, почему система устроена именно так.

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

Карьерный потолок: почему технических знаний недостаточно

Почему одни разработчики быстро растут профессионально, а другие годами остаются на одном уровне, даже обладая серьезными техническими знаниями?

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

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

Еще один важный момент — отношение к собственным ошибкам. 

Кто-то после неудачного решения начинает защищать его до последнего просто потому, что это «его» решение. Другой способен признать, что оказался неправ, понять причину и сделать выводы. Вторые, как правило, растут намного быстрее. 

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

Обязательно ли программисту становиться руководителем, чтобы развиваться в профессии? Какие альтернативные карьерные траектории существуют?

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

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

Можно консультировать бизнес и помогать компаниям принимать технические решения.

Я знаю немало отличных разработчиков, которые становились плохими руководителями просто потому, что однажды их туда «повысили». Управление людьми — отдельная профессия, и она подходит далеко не каждому. Поэтому карьерный рост в IT не обязательно должен означать переход в менеджмент.

Невидимая сторона разработки: ошибки, ответственность и большие системы

Вы работали с корпоративными и финансовыми IT-системами. Чем разработка таких продуктов отличается от создания обычных сайтов и приложений?

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

В такой разработке ответственность ощущается совсем иначе.

Кроме того, крупные корпоративные системы могут жить десять или пятнадцать лет. Их невозможно просто остановить и сказать: «Сейчас мы полгода все перепишем с нуля». Бизнес не может на это время перестать работать. Поэтому приходится иметь дело с тем, что уже существует: постепенно, осторожно, шаг за шагом улучшать систему, которая продолжает работать каждый день. Это действительно отдельное искусство — практически чинить самолет в полете.

Какие ошибки в разработке могут обойтись бизнесу особенно дорого? Почему иногда последствия неправильных решений становятся заметны лишь спустя месяцы или годы?

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

Проблема в том, что такие ошибки редко проявляются сразу. 

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

Как разработчикам приходится искать компромисс между требованиями бизнеса, сроками и технической надежностью? Приходилось ли вам отстаивать решение, которое руководство изначально не поддерживало?

Компромисс приходится искать практически каждый день. Вопрос только в том, чем именно за него придется заплатить. Я стараюсь не говорить бизнесу просто «нет». Если задачу просят сделать к пятнице, а качественная реализация занимает три недели, нужно объяснить, что именно реально сделать к пятнице, какие риски при этом появятся и что обязательно придется доделать позже. 

В этом случае у бизнеса появляется выбор, а не просто технический запрет со стороны разработчика.

Отстаивать решения мне приходилось много раз, и со временем я сформулировал для себя простое правило: разговаривать с бизнесом нужно не столько о технологиях, сколько о деньгах и рисках. 

Фраза «нам нужен рефакторинг» человеку вне IT мало что говорит. Гораздо понятнее объяснить: «Если мы этого не сделаем, через полгода не сможем быстро выпускать новые продукты или повысится риск проблем с платежами». Когда аргумент касается бизнеса, а не личных технических предпочтений разработчика, его гораздо лучше слышат.

Программист будущего: кого не смогут заменить нейросети

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

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

Но остаются задачи другого уровня. 

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

Если написание кода становится все доступнее, не обесценится ли само умение программировать? За какие компетенции компании будут готовы платить в будущем?

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

Компании будут платить за то, что сложнее сгенерировать автоматически. 

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

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

Что бы вы посоветовали человеку, который только собирается войти в IT? Какие навыки стоит развивать сегодня, чтобы оставаться востребованным через пять–десять лет?

Я бы не советовал зацикливаться на одном конкретном фреймворке: они меняются. Гораздо важнее учить базу — понимать, как устроены данные, как работает сеть, как проектируются системы и почему принимаются те или иные архитектурные решения.

Кроме того, стоит как можно раньше делать реальные проекты, пусть даже небольшие. 

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

Еще я бы обязательно развивал речь и коммуникацию. Значительная часть работы в IT — это необходимость объяснить свое решение другим, услышать аргументы коллег и договориться. И я бы не боялся заходить в незнакомые предметные области — финансы, медицину, логистику, производство. Через пять-десять лет будут особенно нужны не просто «люди, которые знают PHP» или конкретный фреймворк, а специалисты, которые умеют соединить технологию с реальной задачей.