Сайт с ChatGPT готов или только кажется?

В первой части я подробно описал, как проектировал сайт до написания кода: начинал с обычных вопросов, постепенно формировал архитектуру и в итоге получил полноценное техническое задание. Во второй части я уже передал утверждённую спецификацию обратно ChatGPT, зафиксировал Design System и перешёл непосредственно к сборке WordPress Theme и Core.
Но получить ZIP-файлы темы и плагина — ещё не значит получить готовый сайт. На практике именно после первой сборки начался этап, который оказался не менее важным, чем проектирование и разработка.
Нужно было проверить, действительно ли ChatGPT реализовал то, что было описано в ТЗ.
Содержание
- Первая сборка — это ещё не готовый сайт
- ТЗ снова стало главным документом
- Я перестал спрашивать ChatGPT: «Всё готово?»
- «Написано» и «проверено» — разные вещи
- Проверял не только внешний вид
- Отдельно проверял URL
- Потом SEO
- Sitemap я тоже проверял как отдельную систему
- Потом я прошёлся по админке
- Проверка дизайна оказалась отдельной задачей
- Desktop и Mobile проверял отдельно
- Исправление ошибки не должно ломать уже готовое
- Версии тоже пришлось контролировать
- Рабочая версия стала точкой возврата
- Я не хотел видеть «Production Ready» раньше времени
- После тестирования — ещё не конец
- Что изменилось в моём подходе к ChatGPT
- Главный вывод
Первая сборка — это ещё не готовый сайт
Когда работаешь с разработчиком, обычно понятно, что после разработки идёт тестирование. С ChatGPT почему-то легко попасть в другую ловушку: получить код, увидеть работающую страницу и решить, что задача выполнена.
Я довольно быстро понял, что так делать нельзя.
Сайт может открываться, WordPress может не показывать ошибок, а визуально всё может выглядеть нормально. Но это совершенно не означает, что реализована вся архитектура.
Например, можно получить рабочую страницу статьи, но обнаружить, что Primary Topic никак не влияет на URL. Можно увидеть Sitemap, но не проверить, какие именно URL в него попадают. Можно получить Sidebar, который визуально работает, но использует другую логику, чем была заложена в ТЗ.
Поэтому после первой сборки я не стал воспринимать результат как финальную версию.
Я вернулся к исходной спецификации.
ТЗ снова стало главным документом
Здесь пригодился подход, который я использовал ещё на этапе проектирования: все решения были собраны в одном документе, а не разбросаны по десяткам сообщений с ChatGPT.
В моём случае финальное ТЗ состояло из 20 разделов — от структуры сайта и архитектуры контента до дизайна, разработки, адаптива, тестирования и запуска.
Теперь этот документ можно было использовать уже не как инструкцию для разработки, а как чек-лист для проверки результата.
Я начал сравнивать:
что было утверждено в ТЗ → что реально реализовано на сайте.
Именно здесь начали появляться первые расхождения.
Я перестал спрашивать ChatGPT: «Всё готово?»
Это, наверное, один из самых полезных выводов всей работы.
Вопрос:
Всё готово?
почти бесполезен.
Гораздо полезнее дать ChatGPT конкретную спецификацию и попросить проверить реализацию по каждому требованию.
Я стал использовать другой принцип:
Проверь текущую реализацию по утверждённому ТЗ.
Не считай функцию готовой только потому, что код для неё существует.
Для каждого требования укажи фактический статус.
И для проверки ввёл несколько простых статусов:
PASS — требование реализовано и действительно проверено.
FAIL — реализовано неправильно или работает не так, как указано в ТЗ.
NOT IMPLEMENTED — функции вообще нет.
NOT TESTED — реализация существует, но её работа ещё не была реально проверена.
Последний статус оказался особенно важным.
«Написано» и «проверено» — разные вещи
ChatGPT может написать функцию и сразу сделать вывод, что она работает. Но наличие PHP-файла, метода или обработчика ещё ничего не доказывает.
Поэтому я отдельно зафиксировал правило:
Нельзя ставить PASS функции, которая фактически не проверялась.
Если код существует, но я ещё не установил сборку и не проверил поведение на WordPress, статус должен оставаться NOT TESTED.
Это кажется мелочью, но именно такое правило сильно меняет весь процесс разработки с AI.
Вместо:
«Функция реализована — готово»
получается:
«Функция реализована — теперь нужно доказать, что она работает».
Проверял не только внешний вид
Первое, что бросается в глаза после установки новой версии, — дизайн. Поэтому очень легко начать тестирование именно с него: посмотреть Header, карточки, Sidebar, мобильную версию.
Но для моего проекта этого было недостаточно.
Мне нужно было проверить несколько уровней одновременно:
WordPress → функциональность → URL → SEO → дизайн → адаптив → безопасность → производительность.
Например, для обычной статьи проверялась не только сама страница. Нужно было убедиться, что правильно определяется Primary Topic, формируется нужный URL, выводятся Breadcrumbs, работает Related, появляется Sidebar, строится TOC и генерируются корректные SEO-данные.
То же самое касалось кейсов, новостей, архивов, поиска, 404 и остальных типов страниц.
Отдельно проверял URL
Для SEO-проекта URL — это не декоративная часть сайта. Поэтому здесь я не хотел оставлять поведение WordPress «как получится».
В ТЗ уже было определено:
Обычная статья:
/{primary-topic}/{post-slug}/
Кейс:
/cases/{post-slug}/
Новость:
/news/{post-slug}/
Если опубликованный URL меняется, старый должен сохраняться в истории и вести через 301 на новый. При этом выдуманные альтернативные URL не должны автоматически становиться рабочими страницами.
Поэтому проверка строилась по простой логике:
одна сущность → один текущий URL → реальные старые URL через 301 → выдуманные варианты через 404.
Отдельно я проверял изменение slug, Primary Topic, категории, дочерние категории и возможные конфликты маршрутов.
Потом SEO
Следующий большой слой — техническое SEO.
Я проверял:
robots;canonical;- Title и Description;
- Sitemap;
- Breadcrumbs;
- Schema;
- индексируемость архивов;
- дополнительные метки;
- пагинацию;
- Search;
- 404;
- даты публикации и изменения материала.
Здесь особенно важно проверять не только правильные страницы, но и исключения.
Например, обычная статья должна иметь canonical. А страница поиска — наоборот, не должна получать canonical только потому, что какой-то общий SEO-метод автоматически выводит его на всех страницах.
То же самое с пагинацией: страницы page 2+ у меня должны быть с canonical на первую страницу соответствующего архива.
Именно такие мелочи легко пропустить, если просто открыть несколько страниц и посмотреть, красиво ли выглядит сайт.
Sitemap я тоже проверял как отдельную систему
Наличие /sitemap.xml само по себе ничего не доказывает.
Мне было важно проверить, что именно туда попадает.
В Sitemap должны находиться только актуальные индексируемые canonical URL. Старые адреса, источники редиректов, noindex, поиск, 404, вторая и последующие страницы пагинации туда попадать не должны.
То есть проверка Sitemap — это не:
Открывается XML или нет?
А:
Соответствует ли каждый URL внутри XML правилам индексации проекта?
Это уже совсем другой уровень проверки.
Потом я прошёлся по админке
Для меня было важно, чтобы сайтом можно было нормально управлять после разработки. Если для изменения обычного текста, ссылки или настройки приходится лезть в PHP, значит архитектура сделана неправильно.
Поэтому отдельно проверял админку Kerik Online:
Kerik Online
├ Обзор
├ Сайт
├ Контент
├ SEO
├ Перелинковка
├ Редиректы
├ Реклама
├ Интеграции
└ Система
Я смотрел не только на наличие этих разделов, но и на то, действительно ли настройки влияют на сайт.
Например, если текст Telegram CTA изменяется в админке, он должен реально измениться на Frontend. Если я выбираю страницу «Обо мне», система должна использовать именно выбранный WordPress Page ID.
И здесь для себя я окончательно сформулировал ещё одно правило:
Контент и всё, что потенциально может меняться, нельзя зашивать в код.
Тексты, ссылки, меню, изображения, контакты, CTA, описания и другие изменяемые данные должны управляться через WordPress или настройки проекта.
Код должен отвечать за структуру и логику.
Проверка дизайна оказалась отдельной задачей
Во второй части я писал, почему отдельно зафиксировал Design System и попросил ChatGPT использовать его дальше без самостоятельных изменений.
На этапе тестирования это правило пришлось проверять уже на практике.
Я сравнивал страницы между собой: одинаковы ли кнопки, размеры текста, карточки, отступы, цвета, Breadcrumbs, формы и другие компоненты.
AI легко может решить локальную задачу красиво, но немного иначе.
Одна новая страница получает чуть другой Border Radius. В другом месте внезапно появляется новый оттенок синего. Где-то кнопка становится выше. Где-то меняется расстояние между блоками.
Каждое изменение само по себе кажется незначительным. Но если не контролировать такие вещи, через несколько итераций единая дизайн-система начинает расползаться.
Поэтому при исправлении одной страницы я старался не разрешать ChatGPT заново проектировать весь компонент.
Если менялся общий компонент, изменение должно было быть осознанным и применяться ко всему сайту.
Desktop и Mobile проверял отдельно
Ещё одна ошибка — считать, что если Desktop работает, Mobile автоматически тоже будет нормальным.
Нет.
У меня изначально было зафиксировано, что Mobile — не просто уменьшенная копия Desktop. Некоторые элементы меняют расположение и порядок.
Например, Sidebar на Desktop находится рядом с основным контентом, а на мобильной версии должен уходить после него. Header переключается на мобильную композицию, таблицы получают горизонтальный скролл, а карточки перестраиваются под ширину экрана.
Поэтому Desktop и Mobile я воспринимал как два состояния одной системы, которые нужно проверять отдельно.
Исправление ошибки не должно ломать уже готовое
И вот здесь начинается ещё одна характерная проблема разработки через ChatGPT.
Допустим, я нахожу ошибку в Sidebar и прошу её исправить. ChatGPT меняет код, Sidebar начинает работать, но вместе с этим неожиданно меняется ширина основного контента или поведение другой страницы.
То есть локальная задача решена, а уже утверждённая часть проекта сломана.
Поэтому после нескольких итераций я начал формулировать задачи намного жёстче:
Исправь только указанную проблему.
Не меняй утверждённую архитектуру.
Не меняй Design System.
Не затрагивай уже работающие компоненты без необходимости.
А после изменения снова проверял связанные функции.
По сути, каждое исправление становилось маленьким regression test.
Версии тоже пришлось контролировать
Когда проект состоит уже не из одного файла, а из Theme и Core, очень легко потерять понимание, какая версия сейчас установлена и какие изменения в неё вошли.
Поэтому Theme и Core получили независимые версии.
Например:
Kerik Online Theme 1.x.x
Kerik Core 1.x.x
После каждого изменения я должен понимать:
- какой компонент изменился;
- какая версия была до этого;
- какая стала после;
- что именно исправлено;
- нужно ли обновлять второй компонент;
- проверена ли новая версия.
Это особенно важно, когда предыдущая версия уже работает нормально.
Нельзя просто постоянно перезаписывать «финальный ZIP».
Рабочая версия стала точкой возврата
Ещё один важный принцип, который появился уже во время реальной разработки: если версия работает, её нужно воспринимать как стабильную точку.
Новая версия может быть лучше. Но пока она не проверена, она не должна автоматически заменять рабочую.
Это спасает от ситуации, когда очередное «небольшое исправление» внезапно приводит к Critical Error WordPress или ломает уже работающий функционал.
Поэтому логика стала такой:
Stable version
↓
Изменение
↓
Новая версия
↓
Проверка
↓
PASS
↓
Новая stable version
Если новая версия получает FAIL, я возвращаюсь к предыдущей рабочей сборке и разбираюсь с проблемой отдельно.
Я не хотел видеть «Production Ready» раньше времени
ChatGPT любит подводить итог.
Файл создан, код написан, ZIP собран — и очень легко получить формулировку вроде:
Production Ready.
Но для меня эта фраза теперь означает конкретное состояние проекта, а не красивое завершение ответа.
Поэтому появился Release Gate.
Перед релизом проверяются функциональность WordPress, админка, URL, редиректы, Sitemap, Schema, SEO, адаптив, безопасность, производительность и сами production ZIP-файлы.
Для ошибок я использовал уровни приоритета.
BLOCKER — запуск невозможен.
HIGH — серьёзная проблема, с которой выпускать версию нельзя.
MEDIUM — проблема известна и может быть допущена только осознанно, если она не несёт риска для безопасности, данных, URL или индексации.
Финальное правило получилось простым:
BLOCKER = 0
HIGH = 0
Только после этого сборку вообще можно рассматривать как готовую к Production.
После тестирования — ещё не конец
Даже технически готовый сайт ещё нужно правильно запустить.
Перед открытием индексации я проверял основной домен, HTTPS, настройки WordPress, системные сущности, реальные ID страниц и терминов, контакты, Telegram, SEO Provider, Sitemap и аналитику.
Отдельно важно убедиться, что ограничения, которые использовались во время разработки, сняты: noindex, Basic Auth, maintenance mode и другие временные ограничения не должны случайно остаться на Production.
После наполнения контентом нужен ещё один проход по URL, изображениям, внутренним ссылкам и Sitemap.
И только после этого сайт можно открывать для поисковых систем.
Что изменилось в моём подходе к ChatGPT
Когда я начинал этот проект, задача выглядела довольно просто:
Хочу сделать свой сайт на WordPress.
Но в процессе стало понятно, что самое интересное здесь вообще не генерация PHP-кода.
Главное — правильно построить процесс.
В первой части я сначала заставил себя спроектировать, а не программировать.
Во второй — передал ChatGPT уже утверждённую спецификацию, зафиксировал Design System и только после этого начал собирать сайт.
В третьей — перестал доверять самому факту наличия кода и начал проверять результат относительно исходного ТЗ.
В итоге весь процесс для меня выглядит так:
Идея
↓
Вопросы
↓
Архитектура
↓
Техническое задание
↓
Design System
↓
Фиксация спецификации
↓
Передача полного ТЗ обратно ChatGPT
↓
Сборка
↓
Аудит реализации
↓
Исправления
↓
Regression testing
↓
Release Gate
↓
Production
Именно замкнутая цепочка здесь оказалась самой важной.
Главный вывод
ChatGPT действительно может помочь создать полноценный WordPress-проект — от первых вопросов об архитектуре до собственной Theme, Core и готового сайта.
Но я бы не строил такой проект по принципу:
попросил → получил код → установил → готово.
Для себя я пришёл к другому подходу:
сначала спроектировать → зафиксировать → собрать → проверить → только потом выпускать.
Чем больше становился проект, тем важнее было не количество сгенерированного кода, а наличие правил, которые не позволяли ChatGPT каждый раз интерпретировать задачу заново.
В результате ТЗ стало не просто документом для начала разработки. Оно прошло через весь проект: сначала определяло, что нужно построить, потом использовалось для сборки, а в конце стало основой для проверки того, что в действительности было построено.
И, пожалуй, это главный вывод всей серии: AI хорошо ускоряет разработку, но управлять проектом всё равно должен человек.
Больше практики и наблюдений - в Telegram
Пишу о SEO, рекламе, разработке и AI на примерах из реальных проектов.


