Программист написал 10 строк кода. AI может заработать на них больше него

Представьте обычную рабочую задачу.

Программист пишет десять строк кода. Они делают ровно то, что нужно: принимают запрос, обращаются к API и возвращают результат. Через пару минут эти строки переписывает AI. Другой AI проверяет их. Третий предлагает исправление. Разработчик принимает изменения и отправляет их в продакшен.

Через некоторое время этот небольшой кусок кода оказывается частью SaaS-сервиса, которым пользуются тысячи человек.

Кто создал этот продукт?

Формально ответить легко: в Git есть коммит, у коммита есть автор, у репозитория есть владелец. Но если смотреть на сам процесс, становится гораздо интереснее.

Человек придумал, что должно произойти. AI написал часть реализации. Другой инструмент её проверил. Ещё один агент мог вызвать API, изменить несколько файлов и подготовить pull request.

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

Десять строк раньше были результатом

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

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

Поэтому возникала простая связь:

больше квалификации → быстрее пишется код → дороже работа программиста.

AI начал ломать эту связь.

Сегодня специалист может описать задачу обычным языком и получить рабочий вариант функции за минуты. Причём речь уже не только об автодополнении. По данным исследования JetBrains за 2026 год, 90% опрошенных профессиональных разработчиков использовали AI-кодинговые агенты на работе хотя бы раз в неделю, а 68% - ежедневно. Исследование проводилось среди более чем 15 тысяч разработчиков по всему миру.

Это важная граница.

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

GitHub уже учитывает такие сценарии даже в собственной системе биллинга: pull request, созданный Copilot cloud agent, может иметь человеческого соавтора, к которому привязывается использование AI.

Получается странная ситуация.

Человек может написать десять строк. Но десять строк уже не обязательно являются главным результатом его работы.

Самое дорогое место находится не в редакторе

Допустим, два программиста получили одинаковую задачу:

Сделать сервис, который принимает фотографии чеков и превращает их в структурированные данные.

Первый написал API на PHP.

Второй тоже написал API на PHP.

Если оценивать только код, различий может быть немного.

Но первый программист сделал небольшой внутренний скрипт.

А второй:

• подключил OCR;

• продумал повторную обработку неудачных запросов;

• сохранил историю операций;

• добавил авторизацию;

• поставил лимиты;

• настроил оплату;

• собрал документацию;

• разместил сервис в облаке;

• подключил мониторинг;

• нашёл клиентов.

В какой-то момент становится очевидно: стоимость проекта находится не в нескольких сотнях строк PHP.

Код - только один из компонентов.

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

Программист всё меньше продаёт способность быстро напечатать цикл for.

Зато ему приходится продавать способность понять, какой цикл вообще нужен.

А теперь уберём программиста из середины

Здесь начинается более интересная часть.

Раньше цепочка выглядела примерно так:

идея → программист → код → приложение → пользователь.

Теперь она может выглядеть иначе:

идея → AI-агент → несколько API → несколько AI-моделей → код → инфраструктура → приложение → пользователь.

Человек при этом может находиться не в центре цепочки, а сверху.

Он ставит задачу и контролирует результат.

Это уже не фантазия о далёком будущем. В 2026 году инструменты для agentic coding всё чаще строятся именно вокруг делегирования сложных задач. OpenAI, например, описывает Codex как инструмент для работы с более сложными задачами разработки, выходящими за пределы обычного автодополнения.

И это меняет экономику.

Если один разработчик раньше производил условные 100 единиц программного кода за день, а теперь с AI может производить 500, рынок не обязан начать платить ему в пять раз больше.

Потому что код перестаёт быть дефицитом.

Если предложение резко выросло, цена самого товара может снижаться.

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

Но есть важная деталь.

AI может сделать код дешёвым, но не делает дешёвыми клиентов.

API может стоить дороже приложения

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

Саму библиотеку можно скопировать.

Её можно попросить написать у Claude.

Её можно попросить переписать у Codex.

Её можно заменить другой библиотекой.

А теперь представим API, которое эта библиотека обслуживает.

У API есть пользователи.

Есть документация.

Есть база данных.

Есть история запросов.

Есть интеграции.

Есть SLA.

Есть биллинг.

Есть данные.

Есть репутация.

Есть инфраструктура.

Вот здесь появляется настоящая стоимость.

И это одна из причин, почему разговор «AI пишет код, значит программисты больше не нужны» слишком примитивен.

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

И это касается не только крупных компаний.

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

AI помогает написать backend.

Другой инструмент генерирует интерфейс.

Третий анализирует ошибки.

Четвёртый помогает с документацией.

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

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

Но тут появляется проблема с авторством

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

Она постепенно становится юридической.

16 сентября 2026 года Девятый окружной апелляционный суд США рассмотрел дело Doe v. GitHub, связанное с GitHub Copilot и OpenAI Codex.

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

Суд не согласился с этой частью претензии.

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

Это решение не означает, что вопрос авторства AI-кода закрыт.

Скорее наоборот.

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

Представьте цепочку:

разработчик A написал код → код попал в публичный репозиторий → модель обучилась на огромном массиве данных → разработчик B попросил AI решить задачу → модель сгенерировала похожий фрагмент → разработчик B изменил его → другой AI проверил результат.

Теперь попробуйте одним именем назвать автора конечного результата.

Задача становится значительно сложнее.

GitHub показывает одного автора. История создания может быть совсем другой

Git традиционно очень хорошо отвечает на вопрос:

Кто внёс это изменение?

Но современная разработка постепенно требует другого вопроса:

Кто и каким способом создал это изменение?

Это не одно и то же.

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

Если он вставил предложение Copilot - уже сложнее.

Если AI сгенерировал весь файл - ещё сложнее.

Если агент сам изучил репозиторий, изменил восемь файлов, запустил тесты и подготовил pull request - привычная модель авторства начинает выглядеть странно.

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

И это, возможно, только начало.

Потому что следующим шагом становится вопрос не «кто написал строку», а кто отвечает за результат.

Ответственность остаётся у человека

Есть неприятная особенность AI-кода.

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

AI не знает бизнес-контекст автоматически.

Он может не знать, что определённый пользователь имеет особые права.

Может не понимать, почему старый endpoint нельзя удалить.

Может не знать, что данные нельзя хранить определённым образом.

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

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

Допустим, AI написал их за пять секунд.

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

Поэтому новый программистский навык выглядит немного парадоксально:

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

Это уже не про скорость набора.

Это про контроль.

Возможно, программист будущего будет писать меньше кода

В этом есть определённая ирония.

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

Но это не обязательно означает, что он станет менее ценным.

Хороший инженер может вообще не написать большую часть реализации самостоятельно.

Он может:

сформулировать требования;

выбрать архитектуру;

разбить задачу;

дать агенту доступ только к нужным системам;

проверить изменения;

запустить тесты;

найти ошибку в логике;

изменить требования;

отправить результат в продакшен.

При этом в Git может оказаться несколько тысяч строк, которые почти никто не печатал руками.

И вот здесь старый вопрос «сколько кода написал программист?» начинает терять смысл.

Гораздо полезнее спросить:

какую работающую систему он смог создать?

Самая дорогая часть может вообще не быть кодом

У этого изменения есть ещё один эффект.

Когда создание приложения становится дешевле, становится дешевле экспериментировать.

Раньше идея могла умереть на этапе:

«На это нужен месяц разработки».

Теперь похожая идея иногда проверяется за вечер.

AI может собрать прототип.

Разработчик подключит API.

Получится первая версия.

Её можно показать десяти пользователям.

Если никто не заинтересовался - проект закрывается.

Если заинтересовались - развивается дальше.

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

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

И это меняет саму профессию.

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

Тогда почему AI может заработать на десяти строках больше программиста?

Потому что AI не обязательно продаёт эти десять строк.

Именно здесь заголовок статьи становится немного обманчивым.

Допустим, программист написал десять строк для API.

Сам по себе этот код может стоить условные копейки.

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

Она продаёт доступ к модели.

Она продаёт инфраструктуру.

Она продаёт подписку.

Она продаёт API.

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

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

Получается парадокс.

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

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

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

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

Поэтому главный дефицит меняется

Раньше дефицитом был сам код.

Потом дефицитом стало время хорошего программиста.

Теперь постепенно дефицитом становится другое:

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

AI может предложить пять реализаций.

Может написать тысячу строк.

Может переписать их ещё раз.

Может провести тесты.

Может найти несколько ошибок.

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

И чем дешевле становится производство кода, тем заметнее становится разница между:

«Я умею программировать»

и

«Я умею создать работающий продукт».

Это уже совершенно разные навыки.

А что будет с обычными программистами?

Здесь не стоит делать слишком красивый прогноз.

Часть задач действительно может стать дешевле.

Особенно тех, где требования понятны, код типовой, а цена ошибки невысока.

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

Но одновременно появляются новые задачи.

Нужно проектировать взаимодействие AI-агентов с инфраструктурой.

Нужно контролировать доступ.

Нужно проверять сгенерированный код.

Нужно разбираться с данными.

Нужно строить тестирование.

Нужно понимать ограничения моделей.

Нужно решать, когда агенту можно дать доступ к продакшену, а когда нельзя.

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

Поэтому профессия может не исчезнуть, а сместиться вверх по цепочке.

От написания функций - к проектированию систем.

От строк кода - к решениям.

От реализации - к контролю результата.

Мы действительно перестаём точно знать, кто написал код

И вот здесь возвращается исходный вопрос.

Программист написал десять строк.

AI переписал их.

Другой AI проверил.

Разработчик внёс изменения.

Ещё один агент создал тесты.

GitHub сохранил commit за человеком.

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

Но системе всё равно нужен человек, который скажет:

«Да, это можно выпускать».

Возможно, именно это и станет новой единицей ценности программиста.

Не количество написанных строк.

Не количество закрытых тикетов.

И даже не скорость печати.

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

AI делает производство кода дешевле.

Но пока он не сделал дешевле ответственность за работающий продукт.

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

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