Ещё один архитектор правил для ИИ-агентов

Проблема, которую ощущают многие, но решают немногие.

Вы запускаете Zed, Kiro, Cline, Claude Code или Qwen. Описываете задачу. Агент создаёт код. И вот он перед вами… Иногда качественный. Иногда — беспорядочная смесь чужих стандартов, случайных шаблонов и игнорирование структуры вашего проекта.

Вы поправляете. Объясняете снова. Поправляете. Через час понимаете: вы тратите больше времени на управление агентом, чем на саму задачу.

Знакомо?

Почему агенты «тупят»

Дело не в модели. Claude, GPT, Gemini, Qwen — все они достаточно “умные”.
Проблема в другом: У агента нет контекста вашего проекта.

Он не знает ваш стек. Не знает ваши конвенции. Не знает, что вы используете Zustand, а не Redux. Что тесты лежат рядом с компонентами, а не в отдельной папке. Что API всегда возвращает { data, error, meta }. Что нельзя трогать папку legacy/ без согласования.

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

Что делает DEMIURGOS

DEMIURGOS — это ИИ-агент, который создаёт правила для других ИИ-агентов.

Вы рассказываете ему о своём проекте. Он задаёт точные вопросы. А затем генерирует набор файлов, которые ваш coding-агент читает автоматически при каждом запуске.

Результат: агент знает ваш проект с первого сообщения. Без повторных объяснений. Без «нет, я же говорил, у нас TypeScript strict mode». Без постоянных исправлений формата.

Как это работает: 3 слоя

┌─────────────────────────────────────┐
│  Ядро (.rules/)                     │  ← Мозг. Источник правды о проекте.
├─────────────────────────────────────┤
│  NATIVE ADAPTERS                    │  ← Проекции для каждого агента.
│  AGENTS.md │ .cursor/ │ CLAUDE.md   │
│  .github/copilot-instructions.md    │
├─────────────────────────────────────┤
│  EXTENSIONS                         │  ← Только если реально нужны.
│  subagents │ hooks │ MCP            │
└─────────────────────────────────────┘

Слой 1 — Ядро. Один набор правил. Единственный источник правды. Описывает: кто агент, что ему можно, чего нельзя, как выглядит хороший код в вашем стеке, какие паттерны использовать, какие — нет.

Слой 2 — Native Adapters. Тонкие проекции ядра для конкретных агентов. Cursor хочет .mdc файлы с YAML frontmatter? Получит. Claude Code читает CLAUDE.md ^[1]? Сгенерирован. Copilot ждёт .github/copilot-instructions.md ^[2]? Готово. При этом ни один факт не дублируется — адаптеры ссылаются на core.

Слой 3 — Extensions. Сложные штуки: мульти-агентные системы, event-driven хуки, MCP-интеграции. Создаются только когда доказана необходимость, а не «на будущее».

22+ инструмента. Один набор правил.

Вы создаёте правила один раз, и они работают везде:

┌─────────────────────────────────┬────────────────────────────────────────┐
│ Где                             │ Как читается                           │
├─────────────────────────────────┼────────────────────────────────────────┤
│ Cursor                          │ .cursor/rules/*.mdc
auto-attach по   │
│                                 │ glob                                   │
├─────────────────────────────────┼────────────────────────────────────────┤
│ Windsurf                        │ .windsurf/rules/*.md — Always On +     │
│                                 │ Model Decision                         │
├─────────────────────────────────┼────────────────────────────────────────┤
│ Claude Code                     │ CLAUDE.md + slash commands             │
├─────────────────────────────────┼────────────────────────────────────────┤
│ GitHub Copilot                  │ .github/copilot-instructions.md +      │
│                                 │ agents                                 │
├─────────────────────────────────┼────────────────────────────────────────┤
│ Kiro                            │ .kiro/steering/*.md — always/auto/     │
│                                 │ manual                                 │
├─────────────────────────────────┼────────────────────────────────────────┤
│ JetBrains / Junie               │ guidelines.md + ACP протокол           │
├─────────────────────────────────┼────────────────────────────────────────┤
│ Codex, Amp, Goose, Aider,       │ AGENTS.md — универсальный формат       │
│ Devin, Zed, Warp, Cline, Qwen...│                                        │
└─────────────────────────────────┴────────────────────────────────────────┘

Один разработчик использует Cursor. Другой — Claude Code. Тимлид — Copilot в VS Code.
Все работают по одним и тем же правилам.

Переехали с Cursor на Windsurf? Core остался. Пересобрали один адаптер. 5 минут.

Что внутри правил: пример для React + TypeScript проекта

Вот что DEMIURGOS создаст (упрощённо):

_index.md ^[3] — мозг ^[4] агента:

Ты Senior React Developer. Стек: React 19, TypeScript 5.6 strict, Zustand, TanStack Query, Tailwind 4. Пиши только функциональные компоненты. Ответ = полный файл с путём. Никогда не хардкодь API-ключи.

patterns.md ^[5] — как писать код (с вариантами):

Вот 2 способа обработки загрузки данных. Вариант A — с TanStack Query (предпочтительный). Вариант B — с useEffect + Zustand (если запрос не кэшируется). Антипаттерн: fetch в useEffect без cleanup.

constraints.md ^[6] — границы:

✅ Всегда: strict TypeScript, error boundaries, aria-атрибуты.
⚠️ Спроси сначала: новые зависимости, миграции БД, git push.
🔴 Никогда: any, inline styles, console.log в продакшне.

eval.md ^[7] — самопроверка перед ответом:

🔴 Безопасность: секреты не зашиты в код? Синтаксически валиден? TypeScript без any?
🟡 Следует паттернам? Error handling? В scope задачи?

Агент читает это до того, как начинает работать. Не после. Не «если попросят». Автоматически.

5 причин использовать DEMIURGOS

1. Агент перестаёт «забывать»
   Правила хранятся в файлах проекта. Они в git. Они загружаются автоматически. Новый чат? Агент уже знает всё. Новый разработчик в команде? git pull — и его агент работает так же, как ваш.

2. Правила минимальны и точны
   DEMIURGOS использует расширение территории по трём осям:

   Размер знаний × количество агентов × уровень расширений.
   – Маленький проект получит 2-3 файла.
   – Масштабный репозиторий — 14+.

   Никогда больше, чем нужно.

Перед созданием каждого файла срабатывает оценка сложности:

Это решает реальную проблему?
Без этого агент станет работать хуже?
Можно решить одной строкой в существующем файле?
Если хоть один ответ «нет» — файл не создаётся.

Мы заложили в DEMIURGOS принципы, которые напрямую определяют качество:

• U-shaped attention — критичное в начало и конец файлов, справочное — в середину.
  Потому что LLM теряет внимание ^[8] в середине длинного контекста.

• KV-cache awareness — статичная информация вверху, динамичная внизу.
  Это ускоряет ответы и снижает стоимость API.

• Structured variation — паттерны даются в 2-3 вариантах, а не как единственный «золотой стандарт». Агент не становится хрупким.

• DRY — каждый факт живёт в одном месте. Если правило обновилось — оно обновилось везде.

Встроенная проверка качества

Перед тем как отдать вам файлы, DEMIURGOS прогоняет 3-5 типовых сценариев:

• «Добавь новый API endpoint» — агент найдёт нужное правило? Формат ответа понятен?

• «Зарефакторь модуль» — permissions не заблокируют? Стайлгайд применится?

• «Почини баг в авторизации» — safety-правила сработают?

Если что-то не проходит — правила корректируются до того, как вы их получите.

Живой документ, а не артефакт

Правила — не «поставил и забыл». DEMIURGOS включает расписание обновлений:

┌─────────────────────────┬────────────────────────────────┐
│ Когда                   │ Что делать                     │
├─────────────────────────┼────────────────────────────────┤
│ Одна и та же ошибка     │ Добавь правило                 │
│ дважды                  │                                │
├─────────────────────────┼────────────────────────────────┤
│ Правило мешает          │ Удали или смягчи               │
├─────────────────────────┼────────────────────────────────┤
│ Агент игнорирует        │ Перемести выше, добавь пример  │
├─────────────────────────┼────────────────────────────────┤
│ Раз в месяц             │ Полный аудит                   │
└─────────────────────────┴────────────────────────────────┘

Для кого это всё

┌─────────────────────┬────────────────────────────────────────────────┐
│ Вы                  │ Что получите                                   │
├─────────────────────┼────────────────────────────────────────────────┤
│ Соло-разработчик    │ Агент, который помнит ваш стек и стиль между   │
│                     │ сессиями                                       │
├─────────────────────┼────────────────────────────────────────────────┤
│ Команда 2-5 человек │ Единые правила для всех, независимо от IDE     │
├─────────────────────┼────────────────────────────────────────────────┤
│ Команда 5+          │ Ядро + мульти-агентная система с ролями        │
├─────────────────────┼────────────────────────────────────────────────┤
│ Тимлид / техлид     │ Архитектурные решения, зашитые в поведение     │
│                     │ агента                                         │
├─────────────────────┼────────────────────────────────────────────────┤
│ Компания            │ Стандарты безопасности и качества, защита на   │
│                     │ уровне ИИ                                      │
└─────────────────────┴────────────────────────────────────────────────┘

Как начать

1. Скачайте ^[9] DEMIURGOS в корень вашего проекта.

2. Начните диалог, фразой: запусти роль DEMIURGOS_NN.md

3. Ответьте на 5-15 вопросов (зависит от размера проекта).

4. Получите готовые файлы ролей и правил именно под ваш проект.

5. Ваш котик-агент стал умнее. Ура)

   Время: 15-30 минут на настройку. Экономия: часы каждую неделю.

Подытожим

Вам больше не нужно постоянно объяснять контекст. Достаточно описать его один раз. Агент автоматически будет следовать вашим правилам.

Это уже не просто файл AGENTS.md, а система правил и ролей, которая живёт в вашем репозитории и делает ИИ-агента по настоящему вашим напарником.