Почему не работает практика 'учись на своих ошибках' для джуниоров

Полгода назад я нанял трёх джуниоров.

Сеньор сказал: "Пусть учатся на своих ошибках. Так быстрее поймут."

Через два месяца все трое делали те же ошибки. Ничему не научились.

История джуниора Максима:

Максим написал код. Отправил на ревью.

Сеньор: "Тут N+1 запросы. Исправь."

Максим исправил. Через неделю новая задача - снова N+1.

"Максим, опять N+1."

"Ой, извините."

Исправил. Ещё через две недели - опять.

Я не понимал. Он же делал ошибку три раза. Почему не учится?

Спросил Максима: "Ты понимаешь что такое N+1?"

"Ну... вроде да. Это когда много запросов."

"А почему это плохо?"

"Эээ... не знаю. Вы просто говорите исправить."

Вот в чём дело. Он не понимал ПОЧЕМУ это ошибка. Просто исправлял где скажут.

История джуниора Ольги:

Ольга написала функцию на 200 строк.

Код-ревью: "Слишком длинная функция. Раздели на части."

Ольга разделила. На следующей задаче - снова функция на 200 строк.

"Ольга, опять длинная."

"Но мне так проще..."

"Нужно делить."

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

Я спросил: "Почему длинные функции плохо?"

"Не знаю. Просто все так говорят."

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

История джуниора Сергея:

Сергей сделал задачу. Без тестов.

"Сергей, где тесты?"

"Ой, забыл."

Дописал тесты. Следующая задача - снова без тестов.

"Сергей, тесты!"

"Сейчас добавлю."

Третья, четвёртая задача - то же самое.

Я спросил: "Почему ты не пишешь тесты сразу?"

"Ну... забываю. И не понимаю зачем если код работает."

Он не видел ценность тестов. Писал их потому что "надо", а не потому что понимал зачем.

Что я понял:

"Учись на ошибках" не работает потому что джуниор:

1. Не понимает ПОЧЕМУ это ошибка

Максим знал что N+1 - плохо. Не знал почему.

1. Не видит паттерн

Ольга исправляла конкретные функции. Не понимала общий принцип.

1. Не понимает последствия

Сергей не видел что будет если не писать тесты.

Без понимания - просто исправляет где скажут. Не учится.

Что я изменил:

Теперь на код-ревью объясняю:

Максим сделал N+1. Раньше:
"Исправь N+1."

Теперь:
"Видишь тут N+1? Для каждого пользователя делаешь отдельный запрос. Если 1000 пользователей - 1000 запросов. База тормозит. Добавь eager loading - будет 1 запрос. Понял?"

"Ааа, теперь понял!"

Следующая задача - сам увидел и исправил до ревью.

Ольга написала длинную функцию. Раньше:
"Раздели."

Теперь:
"Представь вернёшься к этому коду через месяц. 200 строк - не поймёшь что делает. Раздели на 4 функции по 50 - сразу понятно. Ещё и переиспользовать можно."

"Логично!"

Следующая задача - сама разделила.

Сергей не написал тесты. Раньше:
"Добавь тесты."

Теперь:
"Без тестов не знаешь что сломал при изменении. Через месяц кто-то поменяет код - всё упадёт. С тестами сразу видно. Напиши 3 теста."

"Понял."

Следующая задача - написал тесты сам.

Через два месяца:

Максим сам находит N+1 до ревью.

Ольга пишет короткие функции сразу.

Сергей пишет тесты без напоминаний.

Они поняли ПОЧЕМУ. Теперь учатся.

Вывод:

"Учись на ошибках" работает для сеньоров - они понимают контекст.

Для джуниоров не работает - они не знают ПОЧЕМУ это ошибка.

Правильно: объясняй ошибку + причину + последствия.

Не "исправь", а "вот ошибка, вот почему плохо, вот как правильно".

Тогда джуниор учится. Не повторяет.

А как вы учите джуниоров?