Код был правильным — мы просто не могли его прочитать

Есть фраза которую всё чаще слышат в инженерных командах: «Мы особо не проверяли. Но работает».

Год назад это предложение остановило бы любого техлида. Сегодня оно скользит мимо. Что-то изменилось за последние полгода - и это изменение важнее чем кажется.

Что мы раньше умели проверять

Разработчики всегда отдавали что-то взамен на удобство. Перестали писать на ассемблере. Перестали управлять памятью вручную. Перестали читать машинный код который генерирует компилятор.

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

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

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

Реальная история из практики

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

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

Но агент никогда не консолидировал.

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

У агента нет «позже». Он произвёл сороковой кейс так же легко как первый. В итоге синхронизация событий оказалась размазана по всей системе - без единого места где можно посмотреть и понять что происходит.

Ничего не сломалось. Всё работало. И нельзя было ответить на простой вопрос через осмотр кода: что именно мы отправляем и когда?

Корректность локальна. Читаемость глобальна.

Это различие важно. Можно проверить любое отдельное изменение и всё равно пропустить что система в целом перестала быть объяснимой. Ни одно правильное решение не защищает читаемость целого - потому что целое никогда не является проблемой одной задачи.

Когда недели спустя пришло время добавлять ещё события - некоторые из них стреляли в моменты которые не имели смысла. Отладка означала ручную реконструкцию того что отправляется и откуда. Именно то что рассредоточенная структура сделала трудным.

Читаемость - это не удобство которое добавляешь когда система уже работает. Это то что делает следующую проблему находимой.

Почему человек консолидировал бы

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

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

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

Что делать

Не читать каждую строчку - эта граница ушла и не вернётся. Большую часть сгенерированного кода можно не читать так же как не читаешь ассемблер.

Но есть три вещи которые стоит делать намеренно:

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

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

Структуру делает человек. Человек строит центральный канал, агент подключает каждый кейс к нему. Не потому что design-first это добродетель - а потому что у того кто производит объём нет причин сходиться к единой форме.

Раньше раздражение от сороковой одинаковой вещи было предупреждением. ИИ убрал это раздражение. Вместе с ним убрал и предупреждение.

Читаемость больше не заботится о себе сама. Это дисциплина которую защищаешь намеренно - или наблюдаешь как она уходит одним разумным решением за раз. 🧠