К содержанию
Kerik Online

Как превратить ТЗ в собственную WordPress Theme и Core с помощью ChatGPT

6 октября, 20261 мин чтения

В первой части я рассказывал, как идея сделать собственный сайт постепенно превратилась в полноценное техническое задание из 20 больших разделов. К этому моменту были определены сущности, URL, SEO-правила, административная часть, Frontend, Sitemap, Canonical, Redirects и десятки других требований.

Формально такое ТЗ уже можно было передавать программисту. Но мне стало интересно пойти дальше: если ChatGPT помог мне спроектировать систему, сможет ли он теперь по этой же спецификации написать сам сайт?

Здесь задача изменилась. Нужно было не просто сказать ChatGPT «теперь напиши сайт», а организовать разработку так, чтобы во время написания кода он не начал заново принимать уже принятые мной решения.

Содержание
  1. 1. Большое ТЗ нельзя просто отправить со словами «теперь напиши сайт»
  2. Пример логики Implementation Prompt
  3. 2. Работающий код еще не означает выполненное ТЗ
  4. 3. WordPress, Theme и Core пришлось разделить
  5. Как я определял, куда относится функция
  6. 4. Я специально не стал собирать сайт из десятков плагинов
  7. 5. Отдельной задачей стал Design System
  8. Дизайн тоже нужно зафиксировать
  9. 6. Frontend оказался только половиной работы
  10. 7. Хорошая админка — это не максимальное количество настроек
  11. 8. Автоматизация не должна превращаться в черный ящик
  12. 9. Генерировать весь проект одним огромным запросом было бы ошибкой
  13. 10. ChatGPT всё равно пытался принимать решения самостоятельно
  14. 11. В какой-то момент получилась настоящая WordPress-система
  15. 12. Код написан. Значит, сайт готов?
  16. 13. Что я вынес из этапа разработки
  17. 1. ТЗ и промпт на разработку — разные вещи
  18. 2. Работающий код не равен выполненному ТЗ
  19. 3. Theme и системную логику лучше разделять
  20. 4. Design System нужно фиксировать так же, как архитектуру
  21. 5. Административная часть является частью продукта
  22. 6. Не нужно превращать админку в кабину самолета
  23. 7. Большой проект лучше разрабатывать частями
  24. Что дальше

1. Большое ТЗ нельзя просто отправить со словами «теперь напиши сайт»

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

На практике между техническим заданием и написанием кода понадобился еще один слой. ChatGPT должен был понимать не только то, что требуется реализовать, но и правила работы с самой спецификацией.

Для меня было важно, чтобы во время разработки ChatGPT:

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

Поэтому следующим этапом стал отдельный Implementation Prompt. По сути, это инструкция уже не для проектирования сайта, а для работы ChatGPT в роли разработчика.

Пример логики Implementation Prompt

Перед тобой утвержденная спецификация проекта.

Реализуй проект строго по ней.

Не изменяй архитектурные решения самостоятельно.

Не добавляй функции, которых нет в спецификации.

Не заменяй утвержденную реализацию альтернативной только потому, что она проще.

Все утвержденные АКСИОМЫ являются обязательными ограничениями.

Если между требованиями обнаружен конфликт — остановись и сообщи о нем.

Работающий код не считается выполнением задачи, если он не соответствует спецификации.

Последняя фраза стала для проекта особенно важной. Потому что «работает» и «реализовано по ТЗ» — это две совершенно разные проверки.

2. Работающий код еще не означает выполненное ТЗ

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

Предположим, функция должна иметь автоматическое значение, ручное переопределение в админке, проверку входных данных и fallback при ошибке. ChatGPT может написать версию, которая выполняет основную задачу, но не реализует два последних сценария.

На сайте всё будет выглядеть нормально. Ошибок PHP нет, страница открывается, функция работает — и очень легко решить, что задача выполнена.

Но относительно технического задания это уже неполная реализация. Поэтому я отдельно зафиксировал еще одно правило:

АКСИОМА: работающий код ≠ выполненное ТЗ.

После этого при разработке вопрос стал звучать не «работает ли функция?», а «реализованы ли все требования этого раздела спецификации?». Небольшая разница в формулировке, но она сильно меняет подход к работе с AI.

3. WordPress, Theme и Core пришлось разделить

Следующим фундаментальным вопросом стала архитектура самого WordPress-проекта. Можно было положить практически всю собственную функциональность в тему, и для небольшого сайта такой вариант даже выглядел бы проще.

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

В итоге архитектуру Kerik Online я разделил следующим образом:

WordPress → Kerik Theme + Kerik Core

WordPress остается CMS и отвечает за стандартные сущности, хранение контента и редактор. Kerik Theme занимается представлением сайта, а Kerik Core хранит долгоживущую функциональность и данные проекта.

Как я определял, куда относится функция

Для этого появился очень простой тест:

Если завтра полностью удалить или заменить Theme, должна ли эта функция продолжить существовать?

Если ответ «да», скорее всего, ей место в Core. Если функция определяет внешний вид, сетку, отображение компонентов или поведение интерфейса Frontend, скорее всего, это задача Theme.

Например, шаблон статьи относится к Theme. А системные SEO-правила, URL-логика или данные, которые должны сохраниться после смены оформления, уже не должны зависеть от темы.

Так появилась еще одна аксиома проекта:

АКСИОМА: Theme отвечает за presentation. Kerik Core отвечает за долгоживущую функциональность и данные.

Эта граница оказалась полезной не только технически. После ее фиксации многие дальнейшие вопросы о расположении функций стали решаться значительно проще.

4. Я специально не стал собирать сайт из десятков плагинов

WordPress позволяет решить почти любую задачу установкой готового плагина. SEO, Sitemap, Redirects, Breadcrumbs, Schema, формы, Table of Contents и десятки других функций уже существуют в виде готовых решений.

Для обычного проекта это может быть абсолютно нормальным подходом. Но в Kerik Online мне хотелось построить контролируемую систему и одновременно проверить, насколько далеко можно зайти с собственной реализацией при помощи ChatGPT.

Поэтому для проекта я выбрал принцип clean stack:

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

Это не означает «никаких плагинов вообще». Смысл в том, что установка нового плагина должна быть осознанным архитектурным решением, а не автоматическим ответом на любую новую задачу.

Если WordPress уже умеет это делать, логичнее использовать WordPress. Если функция специфична для Kerik Online и должна существовать независимо от Theme, ее можно реализовать в Kerik Core.

5. Отдельной задачей стал Design System

До этого момента основная работа была связана с архитектурой и Backend. Но параллельно нужно было определить, как вообще должен выглядеть Kerik Online.

С ChatGPT здесь возникает интересная проблема: даже если первая страница получилась удачной, следующая генерация может немного изменить отступы, размеры элементов, кнопки, карточки или типографику. Затем появляется еще один компонент, который снова выглядит немного иначе.

Если постоянно просить:

Сделай красиво.

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

Дизайн тоже нужно зафиксировать

Когда внешний вид основных элементов меня устроил, я начал воспринимать их как часть Design System. В ней фиксируются принципы типографики, контейнеров, отступов, кнопок, карточек, форм, состояний элементов и адаптивного поведения.

После этого задача для ChatGPT меняется. Он уже не должен каждый раз придумывать новый дизайн, а должен собирать новые страницы из существующей визуальной системы.

Условно вместо:

Сделай красивую страницу статьи.

можно дать более точную задачу:

Реализуй страницу статьи в соответствии с утвержденным Design System. Не создавай новые визуальные паттерны, если существующие компоненты решают задачу.

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

6. Frontend оказался только половиной работы

Когда говорят «сделать WordPress-сайт», обычно в первую очередь представляют Frontend. Главная, статья, архив, меню, карточки и адаптивная версия — именно эти элементы посетитель видит на экране.

Но если сайтом действительно пользоваться, не менее важной становится административная часть. Кто-то должен управлять всеми функциями, которые появились в техническом задании.

Для каждого модуля поэтому возникал новый набор вопросов:

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

Получается, что реализовать функцию — это не только написать PHP-класс. Нужно еще решить, как с этой функцией я буду работать через WordPress после запуска сайта.

7. Хорошая админка — это не максимальное количество настроек

Когда создаешь собственный Core, очень быстро появляется желание сделать настройку буквально для всего. Цвет, Sitemap Priority, Canonical, технический параметр — для каждого можно добавить еще одно поле.

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

Поэтому для себя я сформулировал противоположный принцип:

Хороший Backend UX — это не максимальное количество настроек. Это минимальное количество решений, которые человек действительно должен принимать вручную.

Если значение можно безопасно определить автоматически, пусть система делает это сама. Ручное управление нужно там, где существует реальный сценарий переопределения.

Особенно это актуально для SEO-функций. Возможность вручную изменить параметр не означает, что я должен заполнять соответствующее поле при публикации каждой статьи.

8. Автоматизация не должна превращаться в черный ящик

Но здесь легко уйти в другую крайность. Если сделать абсолютно всё автоматически, в какой-то момент перестаешь понимать, что именно система собирается сделать с материалом.

Поэтому для части функций я использовал модель:

Auto → Preview → Override

Система сама предлагает или рассчитывает значение. Я его вижу и при необходимости могу переопределить.

Для потенциально опасных операций логика еще строже:

Detect → Preview → Confirm → Apply

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

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

9. Генерировать весь проект одним огромным запросом было бы ошибкой

К этому моменту у меня уже были большое ТЗ, Implementation Prompt, Design System и понятное разделение Theme/Core. Но это все равно не означало, что теперь нужно одним запросом генерировать весь сайт.

Чем больше задача, тем выше вероятность пропущенного требования. Поэтому разработку я продолжил по тому же циклическому принципу, который использовал при создании ТЗ.

Условно процесс выглядел так:

Раздел спецификации → Реализация → Проверка → Исправление → Фиксация → Следующий раздел

Так значительно проще контролировать, что именно реализовано. Если после генерации сразу двадцати модулей что-то работает неправильно, искать источник проблемы уже намного сложнее.

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

10. ChatGPT всё равно пытался принимать решения самостоятельно

Даже при подробном ТЗ полностью избавиться от этого невозможно. Во время разработки AI периодически выбирает более простой путь, добавляет разумный fallback или интерпретирует неоднозначное требование так, как считает правильным.

Иногда предложенное решение действительно может оказаться лучше. Но проблема не в том, хорошее оно или плохое, а в том, что архитектура проекта к этому моменту уже утверждена.

Поэтому при обнаружении такого изменения я возвращался к исходной спецификации. Если новое решение объективно лучше, сначала нужно изменить ТЗ и только после этого реализацию.

Не наоборот.

Код не должен незаметно становиться новым источником истины проекта.

Источником истины остается утвержденная спецификация. Код является ее реализацией.

11. В какой-то момент получилась настоящая WordPress-система

Постепенно Kerik Online перестал быть просто набором сгенерированных файлов. Появились собственная Theme, отдельный Core, административная часть и связанные между собой модули.

Причем самым интересным для меня оказалось не то, что ChatGPT способен писать PHP. Это было понятно еще до начала эксперимента.

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

12. Код написан. Значит, сайт готов?

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

Но оставался один неприятный вопрос: а действительно ли реализовано всё, что было описано в огромном ТЗ? Проверять это по принципу «я покликал сайт и вроде всё работает» уже было нельзя.

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

  • технические SEO-правила;
  • исключения;
  • fallback-сценарии;
  • права доступа;
  • обработка ошибок;
  • автоматические значения;
  • Sitemap;
  • Canonical;
  • Redirects;
  • Schema;
  • поведение после изменения данных;
  • сценарии, возникающие только при определенных условиях.

Поэтому проверка реализации стала отдельным большим этапом. Для него понадобился уже не промпт разработчика, а Implementation vs Specification Audit.

13. Что я вынес из этапа разработки

Проектирование и программирование с ChatGPT оказались во многом похожими процессами. В обоих случаях главная проблема начинается тогда, когда AI получает слишком много свободы самостоятельно принимать архитектурные решения.

1. ТЗ и промпт на разработку — разные вещи

Техническое задание описывает систему. Implementation Prompt определяет, как ChatGPT должен работать с этой системой во время разработки.

2. Работающий код не равен выполненному ТЗ

Страница может открываться без ошибок, а функция выполнять основную задачу. Это еще не означает, что реализованы исключения, Backend UX, fallback и остальные требования спецификации.

3. Theme и системную логику лучше разделять

Если функция должна пережить замену оформления сайта, ей не место внутри Theme. В Kerik Online эту границу я провел между Kerik Theme и Kerik Core.

4. Design System нужно фиксировать так же, как архитектуру

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

5. Административная часть является частью продукта

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

6. Не нужно превращать админку в кабину самолета

Если система способна безопасно определить значение самостоятельно, не обязательно создавать еще одно поле. Настройки нужны там, где пользователь действительно должен принимать решение.

7. Большой проект лучше разрабатывать частями

После каждого этапа я могу отдельно сверить реализацию со спецификацией. Это надежнее, чем один огромный промпт в стиле «теперь сделай весь сайт».

Что дальше

К этому моменту цепочка выглядела уже так:

ТЗ → Implementation Prompt → Design System → WordPress → Kerik Theme + Kerik Core → Backend UX → Реализация

Сайт уже существовал и работал. Но теперь мне нужно было доказать, что полученный результат действительно соответствует тому, что было спроектировано.

В третьей части я расскажу, как проверял реализацию относительно спецификации, использовал статусы PASS / FAIL / NOT IMPLEMENTED / NOT TESTED, тестировал отдельные модули и в итоге пришел к финальному Release Gate.

Поделиться материаломTelegram
Авторadmin

Больше практики и наблюдений - в Telegram

Пишу о SEO, рекламе, разработке и AI на примерах из реальных проектов.

Перейти в Telegram
Комментарии

Обсудить материал