Подробные статьи о технологиях, определяющих будущее.

Разработчик vs архитектор: когда побеждает каждый

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

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

В прошлом месяце я разбирал диф, где AI-ассистент написал цепочку try/catch для логирования установок нашего расширения для браузера. Сначала он пытался получить email пользователя. Если это падало, откатывался на user ID. Если и это падало, он записывал пожимание плечами: кто-то установил, а кто — неизвестно. Код работал. Но он был неправильным: платформа недавно ужесточила, какие данные об идентичности вообще может запрашивать расширение. Вопрос «разработчик или архитектор» прячется в диффах именно такого рода, и никто не объяснил вам, на какой стороне вы теперь находитесь.

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

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

Разработчик и архитектор: две разные работы

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

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

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

Архитектурные решения, которые вы уже принимаете

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

Вот «до» — то, что выдал ассистент, добросовестно реализуя «логировать, кто установил»:

async function logInstall(req, res) {
let identity = null;
try {
identity = { email: await getUserEmail(req) };
} catch {
try {
identity = { userId: await getUserId(req) };
} catch {
identity = { note: "install without identity" };
}
}
await db.installs.insert({ ...identity, at: new Date() });
res.redirect("/welcome");
}

Пятнадцать строк, три точки отказа и схема, которая вечно должна вмещать «email, или userId, или ничего». Каждый фолбэк незаметно связывает путь установки с API идентичности, поэтому сбой сервиса, работающего за согласием пользователя, теперь может замедлить или сломать вашу воронку онбординга. А строка «кто-то установил, кто — неизвестно» аналитически бесполезна: маркетингу из неё не выжать ничего, что можно использовать. Требование выполнено буквально и провалено по сути.

async function logInstall(req, res) {
await db.installs.insert({ at: new Date() });
res.redirect("/welcome");
// Email is collected on the welcome screen, with consent,
// posted asynchronously — and never gates the install path.
}

«После» — четыре строки. Но обратите внимание, что изменилось на самом деле: не код, а требование. Цель никогда не была в том, чтобы «получить email», она была в том, чтобы «измерять установки и связываться с новыми пользователями». Временная метка измеряет установки. Экран приветствия, где пользователь уже смотрит на окно согласия, — правильное место, чтобы асинхронно запросить email, и там сбой ничего не стоит. Ход архитектора был не в том, чтобы написать меньше кода. Он был в том, чтобы пересмотреть, для чего этот код нужен.

Полезная привычка: перед любым нетривиальным изменением проведите двухминутную инвентаризацию связанности. Спросите, что будет вызывать этот код, что будет вызывать его, и что сломается, если каждый из них станет медленным, упадёт или будет помечен как устаревший. В версии «до» путь установки зависел от двух сервисов идентичности, о которых ему не стоило знать. В версии «после» он зависит от одной таблицы. Именно это число зависимостей, а не количество строк и не цикломатическая сложность, предсказывает ваши будущие инциденты. Ту же закономерность мы видели в том, как AI-ассистенты для кода ломаются предсказуемо и проверяемо: результат локально правдоподобен, а глобально связан.

ADR против неписаного знания: когда что побеждает

Architecture Decision Record намеренно скучен: одна страница с контекстом, решением, рассмотренными альтернативами и принятыми последствиями. И всё. Никаких церемоний и никакого процесса согласования, если вы сами его не хотите. ADR в эпоху AI перешли из категории «было бы неплохо» в обязательные по одной причине: память. У модели её нет. Через полгода кто-нибудь направит ассистента на модуль установки, попросит внести изменение, и тщательные рассуждения о согласии и политике платформы испарятся, если только они не записаны там, где их найдут и люди, и инструменты. ADR в репозитории прочитает тот, кто (или что) будет трогать код дальше.

Неписаное знание действительно выигрывает в некоторых ситуациях, и делать вид, что это не так, — способ, которым ADR заработали репутацию бюрократии. Команда из двух человек, делающая прототип со сроком жизни в несколько недель, не нуждается в записях о решениях: те, кто решает, сидят рядом, а код всё равно перепишут. На таком масштабе устный контекст быстрее, богаче и дешевле. Проблема в том, что команды редко замечают момент, когда они переходят порог: первый новый сотрудник, первая команда, которая использует ваш API, первый инцидент, на вопрос «почему мы сделали так?» у которого нет ответа.

  • Решение дорого отменить: изменения схемы на живых данных, публичные контракты API, привязка к вендору.
  • Решение пересекает границу команд, поэтому затронутые люди не присутствуют, когда оно принимается.
  • Вы уже слышите будущий вопрос: «какого чёрта мы сделали это именно так?»
  • Реализацию сгенерировал AI-инструмент, так что ни один человек так и не проговорил рассуждения вслух.
  • Компромисс неочевиден: вы сознательно принимаете реальную цену (задержку, поверхность для атак на приватность, операционную нагрузку).

Четвёртый пункт — тот, что новый. Когда код пишет человек, рассуждения оставляют следы: сообщения коммитов, аргументы в PR, сама форма попытки. Когда код пишет ассистент, рассуждения существуют только в вашей голове, ненадолго, а потом нигде. ADR — это артефакт, который делает ревью возможным, потому что даёт ревьюерам то, с чем можно сверить код. Без него ревью вырождается в придирки к стилю, пока архитектура тихо дрейфует.

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

Обратимые и необратимые решения в проектировании систем

Самый полезный вопрос в арсенале архитектора такой: насколько дорого мне передумать? Некоторые решения — двусторонние двери. Формат логов, сигнатура внутренней функции, TTL кэша: вернуться к ним можно хоть за день. Другие — односторонние двери. Публичный контракт API, с которым интегрируются внешние клиенты. Схема базы, накопившая полгода продуктивных данных. Поток согласия, от которого теперь зависит ваша юридическая позиция. Пройдя через односторонню дверь, вы платите за пересмотр уже не рефакторингом, а миграцией, графиком депрекейшена и извинениями.

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

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

Как архитектор возражает против требований

Неудобная суть работы архитектора — говорить «нет» тем, кто выше по статусу. «Логировать, кто установил» звучало как требование, но на деле это было решение, которое кто-то заранее придумал для цели «измерять установки и связываться с новыми пользователями». Архитекторы переводят решения обратно в цели, а затем предлагают более дешёвый путь к цели. Этот перевод и есть весь фокус, и никакой инструмент его не делает, потому что весь дизайн инструмента — в том, чтобы подчиняться. Некоторые инженеры загружают в ассистента контекст о пользователях и получают от него приличное суждение. Это помогает на периферии, но модель всё равно не пойдёт на встречу и не скажет маркетингу, что их письмо с follow-up при установке не отправится.

  1. Назовите цель, а не решение: «мы хотим измерять установки и находить новых пользователей».
  2. Предложите дешёвый путь и скажите, что он даёт: логирование временной метки отлично измеряет установки.
  3. Назовите реальную цену дорогого пути: трение с согласием, связанный путь установки, строки, которые маркетинг не может использовать.
  4. Дайте реальный выбор: «если email важен, спрашиваем на экране приветствия, вот однодневная версия этого».
  5. Запишите всё, что решено, чтобы следующий человек не пересматривал это с нуля.

Теперь честное возражение, потому что оно заслуживает внимания: никто никого не повысил. Скорее всего, история такова: вы становитесь стоком ответственности за решения, которые принимала модель, с той же зарплатой и меньшей долей интересного. Я не думаю, что это неправильно, и это причина серьёзнее отнестись к привычке документировать, а не пропускать её. Трасса ADR — это также бумажный след. Быть человеком, который принял решение, становится проблемой только тогда, когда вы не можете показать свои рассуждения. Тот, кто записал «выбрали временные метки вместо сбора email, потому что платформа ограничивает данные об идентичности», защищён. Тот, кто слил всё, что выдал ассистент, — нет.

Разработчик и архитектор: когда побеждает каждый

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

  • Хорошо описанный баг с известным радиусом поражения: побеждает режим разработчика. Воспроизвести, починить, протестировать, выкатить. Архитектурные раздумья здесь — прокрастинация в пиджаке.
  • Прототип для проверки спроса: режим разработчика. Если всё сработает, код перепишут, а если нет, удалят. ADR для одноразовой штуки — пустая трата.
  • Новая фича с размытыми требованиями: сначала режим архитектора, пусть даже на час. Размытость — место, где импульс, созданный AI, наносит максимальный ущерб.
  • Всё, что касается денег, идентичности или согласия: режим архитектора, без исключений. Асимметрия стоимости между построением и откатом здесь максимальна.
  • Изменения схемы на живых данных или изменения публичного API: режим архитектора с ADR, по правилу обратимости.
  • Команда из двух человек, кодовая база младше шести месяцев: режим разработчика с ведущимся файлом заметок. Полная церемония пока ничего не даёт.
  • Регулируемая область или несколько команд-потребителей: режим архитектора с записями, потому что о «почему» спросят аудиторы и незнакомцы, а не друзья.

Провал в обоих направлениях — оставаться в одном режиме. Разработчики, которые никогда не переключаются вверх, поставляют элегантную реализацию не того, что нужно. Архитекторы, которые никогда не переключаются вниз, рисуют схемы для систем, которых не существует. Людей, которых я меньше всего хотел бы потерять в команде, — тех, кто делает и то и другое в один день: спорит о модели данных в 10 утра, а в 14:00 чинит off-by-one без жалоб, что это ниже их достоинства. Если вы строите процесс ревью вокруг вывода AI, стоит почитать о том, как агентные инструменты для кода устроены: циклы, контекст и права доступа, потому что переключение режима должно происходить внутри этого цикла, а не после него.

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

Чертёж со светящимися линиями связи между нарисованными фигурами, развёрнутый рядом с ноутбуком.
Архитектура — это решение о том, какие линии вообще имеют право существовать, до того как их кто-то нарисует.

Рекомендация: берите повышение

Вот моя позиция, и она не «зависит от обстоятельств»: по умолчанию работайте в режиме архитектора со всем, что касается модели данных, внешнего контракта или безопасности, а всё локализованное ведите в режиме разработчика. Распределение не будет 50 на 50: для большинства инженеров это примерно 20% архитектуры и 80% построения, как и всегда. Изменилось то, что построение стало быстрым, а цена пропуска тех 20% выросла ровно во столько же раз. Чем больше печати вы делегируете, тем сильнее ваша ценность концентрируется в той части, которую делегировать нельзя.

Стартовый набор — это три привычки, и все их можно внедрить на этой неделе. Во-первых, добавьте в репозиторий шаблон ADR: контекст, решение, альтернативы, последствия, полстраницы, и напишите один, когда примете реальный компромисс. Во-вторых, добавьте двухминутную инвентаризацию связанности в каждый эпик: что это вызывает, что вызывает это, что сломается при сбое. В-третьих, добавьте вопрос об обратимости в шаблон тикета: «если это окажется неверным, сколько будет стоить передумать?» Если ответ «миграция и извинения», притормозите. Если «полдня», не тормозите.

Работа с кодом никуда не денется, денется работа по печати. Это никогда не было одним и тем же, и тихо паникуют как раз те, чья роль незаметно свелась к переводу задач в синтаксис. Если вы читаете диффы и спрашиваете «почему это связано с API идентичности», вы уже делали работу архитектора. Единственное реальное изменение в том, что теперь это официально, задокументировано и принадлежит вам. Берите повышение.