Как сделать код-ревью, чтобы тебя не возненавидели?

«Почему ты так написал?» — если ваш комментарий в код-ревью начинается с таких слов, будьте готовы к тому, что коллеги разочаруются. Жёсткая критика без контекста, замечания о стиле вместо архитектуры и тон преподавателя, а не ментора, превращают ревью в стресс. Но можно иначе: находить реальные баги, а не придираться к неймингу; объяснять, а не указывать; замечать хорошие решения. Рассказываем, как делать код-ревью так, чтобы ваш фидбек ждали, а не проклинали.

Почему код-ревью — не про власть, а про заботу

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

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

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

Что на самом деле проверяется

В код-ревью обычно проверяется:

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

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

Чек-лист для ревьюера: что смотреть в коде, чтобы все прошло гладко

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

Логика: всё ли понятно и предсказуемо?

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

Код решает задачу или обходит её?

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

• «А зачем тут это условие?»
• «Можно ли решить задачу проще?»
• «Это бизнес-логика или побочный эффект бага?»

Всё ли предсказуемо?

Хорошая логика — это ожидаемое поведение. Когда видишь функцию getUserRoles, и она действительно возвращает роли пользователя, а не делает лишний лог (или хуже, мутирует глобальное состояние).

Нужно проверить:

• Есть ли неожиданные побочные эффекты?
• Не делает ли функция всё подряд?
• Можно ли использовать этот код повторно?

Учитываются ли граничные случаи?

Тестировать happy path — это приятно. Но ревью — момент, когда нужно быть немного параноиком и задавать себе вопросы:

• «А что, если в массиве будет null?»
• «Что вернётся, если база пустая?»
• «Что произойдёт, если API не ответит?»

Если логика ломается при первой же нестандартной ситуации — это нерабочая логика.

Видна ли связь между частями?

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

Архитектура: насколько код ложится в общую картину?

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

Живёт ли код в вакууме

Каждый новый модуль, компонент или класс должен:

• быть в нужном слое архитектуры (не пишем, например, SQL-запросы в React-компоненте),
• располагаться там, где его логически ожидаешь (не прячем бизнес-логику в утилитах),
• использовать существующие механизмы, а не дублировать их.

Следует ли код соглашениям команды

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

Нужно проверить:

• используются ли принятые в команде подходы;
• поддерживаются ли слои;
• повторяет ли структура проекта предыдущие решения.

Безопасность: нет ли уязвимосей?

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

Пользовательский ввод

Всё, что приходит от пользователя (формы, параметры URL, тело запроса), требует внимания. Здесь могут возникнуть SQL-инъекции, XSS и т.д. Поэтому стоит проверить:

• Есть ли валидация данных на стороне сервера?
• Используются ли подготовленные запросы или ORM?
• Обрабатываются ли потенциально опасные символы?
• Предусмотрена ли защита от исполнения произвольного кода?

Доступ к данным и авторизация

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

• Есть ли проверка прав пользователя перед выполнением запроса?
• Реализована ли проверка не только на фронте, но и на сервере?
• Используются ли идентификаторы, которые нельзя легко перебрать?

Тесты: можно ли быть уверенным, что всё работает?

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

Есть ли вообще тесты?

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

Проверяем:

• Есть ли новые юнит- или интеграционные тесты?
• Актуальны ли существующие — не остались ли висящими после изменений?
• Упали ли какие-нибудь тесты в CI — и если да, то почему?

Тестируется ли то, что нужно?

Иногда тесты есть, но проверяют слишком очевидное или не покрывают рисковые места. На что обратить внимание:

• Проверяются ли граничные случаи (например, пустой ввод, null, некорректные данные)?
• Есть ли тесты на негативные сценарии — когда функция должна вернуть ошибку?
• Покрыта ли новая логика?

Понятны ли сами тесты?

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

• Говорят ли названия тестов, что именно они проверяют?
• Можно ли по коду теста быстро понять, зачем он нужен?
• Нет ли странных чисел или непонятных моков?

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

Как давать комментарии и не звучать резко

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

Начните с положительного: что в этом коде уже хорошо

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

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

Что можно хвалить:

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

Примеры фраз:

• «Здорово, что ты вынес логику в отдельный хелпер — теперь это читается в разы легче».
• «Классная идея использовать (вставьте код),а не (вставьте код)— так гораздо понятнее».
• «Круто, что добавил тест на этот кейс — про него часто забывают».

Замечания: только по делу и с предложением, как исправить

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

Так НЕ надо:

• «Плохо читается».
• «Переделай»
• «Зачем???»

Так лучше:

• «Можно упростить, если разделить условие на два блока — сейчас выглядит довольно сложно».
• «Тут, кажется, можно обойтись без цикла: достаточно метода (вставьте метод)— он короче и лучше читается»..
• «В этом месте можно потенциально получить undefined. Может, стоит добавить проверку?»

Говорите прямо, без намёков и иронии

Код-ревью — не место для недосказанностей и полутонов. Комментарии вроде «Ну, если так РЕАЛЬНО работает — ок» звучат пассивно-агрессивно и только создают напряжение. Получивший такое замечание будет гадать: это одобрение, сарказм или тонкий намёк, что я всё сделал не так?

Вместо этого — формулируйте замечания ясно и по существу:

• «В этом месте поведение функции может быть неочевидным — можешь уточнить название или добавить комментарий?»
• «Пока непонятно, почему именно такое условие — можешь пояснить, пожалуйста?»
• «Похоже, тут можно упростить: если заменить на (вставьте код) логика станет короче».

Если вы не уверены, как ваша реплика будет воспринята — переформулируйте. В ревью лучше не пошутить, чем задеть человека, особенно если вы не на 100% уверены в уровне вашей взаимной иронии.

Делайте фокус на код, а не на человека

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

Так НЕ надо:

• «Ты опять забыл обработать ошибку».
• «Почему ты так сделал?!»
• «Это неправильно».

Лучше так:

• «Похоже, здесь не хватает обработки ошибки — может быть сбой».
• «Можешь, пожалуйста, уточнить логику? Кажется, тут может возникнуть исключение».
• «Вот так решение будет стабильнее: предлагаю…»

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

Как сделать код-ревью полезным и для себя

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

Учитесь новому: чужой код — тоже учебник

Читая чужие решения, можно заметить многое: библиотеку или инструмент, который вы раньше не использовали; необычную структуру функции или способ организации логики; паттерн, который вы обычно не применяете, но он к месту и т.д. Это особенно полезно, если вы работаете в мультистековой команде. Кто-то пишет на Python, вы — на C++, но идеи и архитектурные подходы легко переносятся между языками. Подмечайте, как другие подходят к задачам, даже если в целом всё вам понятно — детали часто дают самые интересные инсайты.

Заведите привычку задаваться вопросом: «Что здесь сделано хорошо и почему я сам так не пишу?». Или наоборот — «Почему мне этот кусок кажется странным и как бы я сделал иначе?». Такие наблюдения дают гораздо больше, чем кажется на первый взгляд.

Задавайте вопросы, даже если всё понятно

Иногда вы смотрите код — и вроде всё чисто, логично. Но это как раз повод не просто молча одобрить, а пообщаться с проггером. Почему? Потому что вопросы — не всегда сигнал о проблеме: иногда это инструмент обучения.

Например:

• «А почему решили использовать именно этот метод?»
• «Это кастомное решение или такой подход у нас принят в проекте?»
• «Я раньше делал по-другому — есть ли причины, почему здесь выбрали такой путь?»

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

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

Прокачивайте навык объяснять

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

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

Например, вместо «Это плохой способ», напишите: «Такой подход может усложнить отладку, потому что данные не логируются. Предлагаю использовать вот такой паттерн (укажите паттерн), он делает поведение функции более прозрачным».

Почему это работает:

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

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

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