Вайбкодинг: 99 % покрытия и 9 дыр, которых тесты не видят
Модель написала 6 модулей и 36 тестов: всё зелёное, покрытие 99 %. Мутационное тестирование нашло 9 ошибок, которые эти тесты пропускают. Какие и как их ловить.
* * *
Вайбкодинг — способ писать программы, при котором код по описанию на естественном языке пишет модель, а человек принимает результат по поведению, не читая код; термин ввёл Андрей Карпаты в феврале 2025 года. Для испытания мы взяли крайний, но типичный сценарий: один промпт, та же модель пишет и код, и тесты, код принимается, если тесты зелёные. Шесть модулей, 36 зелёных тестов, покрытие 99 % — а мутационное тестирование показало девять ошибок, которые эти тесты не заметят, включая ту, что отбраковывает примерно каждый одиннадцатый корректный ИНН.
Почему вопрос возник
По Wordstat за 03.08–01.09.2026 (все регионы, все устройства) запрос «вайбкодинг» набрал 23 908 показов, «вайб кодинг» — 15 839, «vibe coding» — 2 657. Хвост этих запросов — «что это», «курсы», «обучение», «бесплатно», «ии для вайбкодинга»; про проверку результата в нём почти ничего: «вайб кодинг тесты» — 2 показа за месяц. Это логично: у вайбкодера уже есть проверка — тесты. Их написала модель, они зелёные, покрытие под сто. Что ещё нужно?
Нужно понять, что именно эти тесты проверяют. Гипотеза: тест, написанный вместе с кодом той же моделью, склонен повторять допущения кода — знать те же примеры, что и реализация, и не знать тех же граничных случаев. Тогда зелёный прогон говорит «код делает то, что я ожидал», а не «код правильный». Проверить это на числах — и есть жанр испытаний в этом журнале.
Проверить, велика ли разница, можно одним инструментом — мутационным тестированием. Оно вносит в код небольшие поломки (мутанты): меняет <= на <, and на or, константу на соседнюю — и запускает тесты. Если тесты остались зелёными, мутант «выжил»: такую поломку ваши тесты не ловят. Для вопроса «ловят ли тесты изменение поведения» доля убитых мутантов информативнее покрытия строк: покрытие считает выполненные строки, мутанты — проверенные.
Что делали
Шесть задач, типичных для запроса «напиши мне»: разбор строки длительности 1h30m в секунды, проверка контрольных чисел ИНН, LRU-кэш, ограничитель частоты вызовов со скользящим окном, слияние интервалов и слаг для адреса из русского заголовка. Каждая — отдельный промпт по одному шаблону:
Напиши на Python модуль
<имя>с<что нужно>. Добавь тесты на pytest.
«Проход» здесь — один запрос и один ответ: без уточнений, без регенерации, без правок и без запуска тестов до того, как файлы легли на диск. Модель — Claude (Anthropic), идентификатор по конфигурации сессии claude-fable-5-1, в агентной сессии редакции без отдельного системного промпта под задачу, параметры генерации по умолчанию. Что вышло, то и легло в src/ и tests/ — ровно так, как это делает вайбкодер. Дальше три команды:
$ python -m pytest -q # зелёные ли тесты
$ python -m pytest --cov=vibe --cov-report=term-missing # покрытие
$ mutmut run && mutmut results # мутанты
Прогон 04.09.2026 в песочнице редакции: Ubuntu 24.04, 2 vCPU Intel Xeon 2,10 ГГц, 7 ГБ памяти, Python 3.11.15, pytest 9.1.1, pytest-cov 7.1.0, coverage 7.16.0, mutmut 3.7.0, hypothesis 6.167.1. Все времена ниже — про эту машину, а не про метод. Код модулей и тестов — в raw/code/, вывод команд — в raw/; как журнал вообще меряет — на странице «О журнале».
Что получилось
real 0m8,205s. Сам mutmut рапортует 28,25 мутанта в секунду — это его метрика по времени мутаций, без сбора и запуска тестов, поэтому 167 ÷ 8 даёт другие 20 в секунду, и оба числа верныПервый заход — то, что получает вайбкодер: 36 тестов, все зелёные меньше чем за секунду, покрытие 99 % (единственная непокрытая строка — одна ветка ошибки в разборе длительности). Мутантов mutmut сгенерировал 167, из них 135 убито и 32 выжило.
Доля убитых — 135 из 167, то есть 80,8 %; без эквивалентных мутантов (о них ниже) — 135 из 161, 83,9 %. Но число в заголовке — не процент, а результат чтения: выживших надо разбирать глазами, и правило разбора лучше назвать до таблицы, а не после.
Мерило — контракт самого модуля: докстринг, аннотации типов и его же сообщения об ошибках. Мутант считается настоящей дырой, если внутри этого контракта он меняет поведение — отвергает допустимый вход, принимает недопустимый или возвращает другой результат. Эквивалентным — если на всей области контракта поведение совпадает с исходным. Шумом — если меняется только текст сообщения об ошибке: контракт фиксирует тип исключения, а не формулировку.
По этому правилу из 32 выживших семнадцать — шум: ValueError("пустая строка") превращался в ValueError(None), тесты проверяли тип исключения, и с точки зрения поведения программы это не поломка. Шесть — эквивалентные: sorted(intervals, key=lambda it: it[0]) и sorted(intervals) для кортежей дают один и тот же порядок; OrderedDict.popitem(last=None) работает как popitem(last=False), потому что None для этого флага ложь. Такие мутанты — шум инструмента, их не ловят, потому что ловить нечего.
Остаются девять. Каждый из них нарушает контракт модуля, и 36 зелёных тестов этого не заметят.
| Модуль | Тестов | Покрытие | Мутантов | Выжило | Из них настоящих дыр |
|---|---|---|---|---|---|
duration | 8 | 95 % | 35 | 8 | 0 |
inn | 7 | 100 % | 42 | 2 | 2 |
lru | 6 | 100 % | 16 | 5 | 1 |
ratelimit | 4 | 100 % | 27 | 9 | 3 |
intervals | 6 | 100 % | 24 | 2 | 0 |
slug | 5 | 100 % | 23 | 6 | 3 |
| итого | 36 | 99 % | 167 | 32 | 9 |
Теперь сами дыры — те, ради которых стоило читать 32 диффа.
Каждый одиннадцатый ИНН. Контрольное число ИНН считается как взвешенная сумма по модулю 11, а затем по модулю 10: если остаток 10, контрольное число — 0 (структуру номера и само наличие контрольного числа задаёт приказ ГНС РФ № ГБ-3-12/309; алгоритм с весами официально не опубликован, реализация — общепринятая, та же, что в бухгалтерских системах и валидаторах). Мутант заменил % 11 % 10 на % 11 % 11, и функция начала отвергать все номера с остатком десять — при равномерном распределении цифр это примерно каждый одиннадцатый корректный ИНН. Семь тестов этого не увидели, потому что ни один из двух ИНН в них не попал в этот класс. Второй мутант в том же модуле заменил and на or в проверке двенадцатизначного ИНН: теперь достаточно одного верного контрольного числа из двух. Тесты проверяли «верный проходит» и «неверный не проходит», но неверный у них был неверен целиком.
Единица — не число. RateLimiter(1, 10) — законный лимит «один вызов в десять секунд» по контракту самого модуля: сообщение об ошибке говорит «max_calls должен быть положительным», а единица положительна. Мутант заменил проверку max_calls <= 0 на max_calls <= 1, и конструктор стал бросать исключение на единице. Тесты создавали ограничители на два и на три вызова и проверяли, что ноль — ошибка. Единица осталась между ними. Та же история с period <= 1: в сигнатуре period: float, полсекунды окна — допустимое значение, и оно перестало быть допустимым. И с LRUCache(1): «ёмкость должна быть положительной», кэш на один элемент законен, тесты его не знают.
Ровно на границе. В скользящем окне старые вызовы вытесняются условием self._calls[0] <= threshold. Мутант сделал <, и вызов, которому исполнилось ровно period секунд, остался в окне. Тесты сдвигали часы на 11 секунд при окне в 10 — граница в них не встречалась ни разу.
Обрезка с хвостом. slugify обрезает длинные слаги и снимает дефис на конце: rstrip("-"). Два мутанта сделали rstrip(None) и lstrip("-") — дефис на конце остаётся, адрес заканчивается на -. Тест на длину проверял строку из двухсот букв «а», в которой дефису неоткуда взяться. Третий мутант сменил значение по умолчанию max_length=80 на 81 — публичный контракт функции изменился, и ни один тест не дрогнул.
Чтобы связь была проверяемой, вот кто кого убивает во втором заходе (тесты — в raw/code/tests/test_qa_boundaries.py):
| Дыра | Мутант | Тест второго захода |
|---|---|---|
| ИНН: остаток 10 → 0 | % 11 % 10 → % 11 % 11 | test_inn_control_remainder_ten_becomes_zero, test_inn_10_property |
| ИНН-12: одно из двух | and → or | test_inn_12_requires_both_control_digits, test_inn_12_property |
| Лимит в один вызов | max_calls <= 0 → <= 1 | test_ratelimiter_one_call_is_valid |
| Окно короче секунды | period <= 0 → <= 1 | test_ratelimiter_fractional_period_is_valid |
| Ровно на границе окна | <= → < | test_ratelimiter_window_edge_is_inclusive |
| Кэш на один элемент | capacity <= 0 → <= 1 | test_lru_capacity_one_is_valid |
| Дефолт длины слага | 80 → 81 | test_slug_default_max_length_is_80 |
| Дефис на конце слага | rstrip("-") → rstrip(None) | test_slug_truncation_does_not_end_with_dash |
| Дефис на конце слага | rstrip("-") → lstrip("-") | тот же тест |
Покрытие кода тестами: 99 % — это не доказательство
Покрытие отвечает на вопрос «выполнялась ли строка», и только на него. Строка if max_calls <= 0 выполнялась в каждом тесте — покрыта на сто процентов. Проверено ли в ней, что граница проходит именно по нулю, покрытие не знает. Все девять дыр сидят в строках с покрытием 100 %.
Отсюда практическое правило: покрытие показывает код, до которого тесты не дошли вовсе, но не силу проверок в коде, до которого дошли. После зелёного прогона смотреть стоит на выживших мутантов — и не общим процентом, а списком с диффами. В этом прогоне 80,8 % убитых выглядят прилично; девять нарушений контракта выглядят иначе. Это не две оценки одного и того же: процент — про все мутанты, девять — про прочитанных выживших.
ИИ в тестировании: пусть пишет тесты, но не принимает их
В этом сценарии тесты повторили слепые зоны кода: модель проверила то, что сама же и предположила, спорить ей было не с кем. Насколько это свойство совместной генерации, а насколько — конкретного промпта, без контрольного варианта сказать нельзя, и об этом честно сказано в «Ограничениях».
Роль тестировщика от этого не исчезает, а сдвигается: первые тесты модель напишет сама, а вот читать выживших мутантов и добивать их — работа человека. Второй заход этого испытания сделан так: 11 тестов — восемь по конкретным дырам из таблицы выше, один на тексты сообщений и два на свойствах через hypothesis, которые генерируют сотни ИНН и проверяют инвариант «верный проходит, с испорченным контрольным числом — нет». Свойство здесь сильнее набора примеров, потому что примеры выбирает тот же человек, что и код, а генератор — нет. Расчёт контрольного числа, на который опирается тест, — три строки из самого модуля:
_WEIGHTS_10 = (2, 4, 10, 3, 5, 9, 4, 6, 8)
def _control_digit(digits, weights):
return sum(d * w for d, w in zip(digits, weights)) % 11 % 10
И тест на свойстве:
@given(st.lists(st.integers(0, 9), min_size=9, max_size=9))
def test_inn_10_property(digits):
c = _control_digit(digits, _WEIGHTS_10)
inn = "".join(map(str, digits)) + str(c)
assert validate_inn(inn) is True
assert validate_inn(inn[:-1] + str((c + 1) % 10)) is False
Результат второго захода: 47 тестов, убито 149 из 167, выжило 18 — двенадцать про текст сообщений и шесть эквивалентных. Настоящих дыр — ноль. Одиннадцать тестов против девяти ошибок, каждая из которых в проде выглядела бы как «странно, у клиента ИНН не проходит».
done in 352ms (7 files mutated, 0 ignored, 0 unmodified)
167/167 🎉 149 🙁 18
28.46 mutations/second
real 0m8.334s
$
Мутационное тестирование за 8 секунд: pytest и mutmut
Главное возражение против мутационного тестирования — цена: на большом проекте прогон занимает часы. Здесь 167 мутантов прошли за 8,3 секунды на двух vCPU, потому что тесты быстрые и модули маленькие. Это тот случай, когда инструмент дешёв ровно там, где вайбкодинг чаще всего применяют: небольшие модули, написанные за один запрос.
Как встроить в поток без боли:
mutmut runпосле зелёного pytest. Между запусками mutmut перепроверяет только мутантов в функциях, чей исходник изменился, а нужный кусок можно запустить по паттерну:mutmut run "vibe.inn*". Новые тесты перепрогон не запускают — об этом ниже.- Читать
mutmut resultsиmutmut show <id>, а не процент. Сортировать выживших на три кучки по правилу выше: шум, эквивалентные, настоящие. Первые две — в исключения или вmatch=уpytest.raises, третья — в тесты. - Писать тесты по диффу мутанта: граница (ровно 1, ровно
period), пара «верно/неверно» для каждого условия, свойство для формулы. - В CI — порог не общий, а по модулям с деньгами и идентификаторами: в
innвыживших с нарушением контракта должно быть ноль. Общий порог «не ниже, чем вчера» — как страховка от деградации.
Что сломалось
Две вещи, о которых честнее сказать, чем промолчать. Первая: после добавления тестов повторный mutmut run показал прежние 32 выживших. По документации mutmut между запусками перепроверяет только мутантов в функциях, чей исходник изменился, — а менялись тесты, не исходник. Понадобилось удалить каталог mutants/ и прогнать заново, иначе второй заход выглядел бы бесполезным. Вторая: 17 мутантов из 32 в первом заходе оказались шумом про тексты сообщений — это половина списка, и без ручной сортировки заголовок был бы «32 дыры», что неправда. Мутационное тестирование измеряет силу тестов относительно набора мутаций, а не правильность реализации; что из выжившего дефект, решает контракт и человек, который его читает.
Ограничения
Одна модель, один стиль промпта, шесть небольших модулей на Python — все выводы здесь про этот эксперимент, а не про «тесты от ИИ» вообще. Контрольного варианта нет: мы не сравнивали с тестами, написанными человеком, другой моделью или по независимой спецификации, поэтому не можем отделить эффект совместной генерации от эффекта конкретного промпта — это следующее испытание. Классификация выживших ручная, по правилу, названному перед таблицей; спор о том, дыра это или нет, ведётся против контракта модуля, а не против вкуса. Время прогона — характеристика этой машины, не метода. Всё для повторения лежит в raw/: те же промпты, другая модель — и сравните число выживших.
Вывод
В этом эксперименте 36 зелёных тестов и 99 % покрытия пропустили девять нарушений контракта: границы на единице, пары «верно/неверно», обрезку на краю. Ловятся они одиннадцатью тестами и восемью секундами мутационного прогона — если после зелёного прогона кто-то откроет список выживших.
Как повторить
- Взять
raw/code/: шесть модулей вsrc/vibe/, тесты первого захода вtests/test_*.py, второго — вtests/test_qa_boundaries.py, конфиг вpyproject.toml. - Linux или macOS; на Windows — только внутри WSL: mutmut 3 требует поддержки
fork. Эксперимент проведён на Python 3.11.15. - Поставить версии из шапки:
pip install pytest==9.1.1 pytest-cov==7.1.0 coverage==7.16.0 mutmut==3.7.0 hypothesis==6.167.1. - Первый заход: временно убрать
tests/test_qa_boundaries.py, выполнитьpython -m pytest -q, затемmutmut run && mutmut results. Ожидается 135 убитых, 32 выживших. - Второй заход: вернуть файл, удалить каталог
mutants/(иначе mutmut не перепроверит мутантов, чей исходник не менялся), повторить. Ожидается 149 убитых, 18 выживших. - Сверить диффы выживших с
raw/05-survivors.diff: список из девяти дыр обязан совпасть. - Чтобы повторить с другой моделью — промпты в
raw/prompt.md, шесть задач, один проход на каждую, без правок.
сырые логи и код: raw/ рядом с этим файлом
✓ подтверждено
В этом испытании тесты, сгенерированные вместе с кодом, пропустили 9 нарушений контракта при покрытии 99 % — границы на единице, пары «верно/неверно», обрезку на краю.
критерий: выжившие мутанты, нарушающие контракт модуля, при зелёных тестах · mutmut 3.7.0 · 04.09.2026 · raw/05-survivors.diff
Сырьё прогона: 25 файлов ↗ команды, версии и логи — те самые, по которым считаны числа