Если вы устали от вау-демо и хотите строить по-настоящему, заведите Perplexity Space, опишите свои правила, разделите проект на фракталы, посмотрите как модель ведёт себя когда у неё впервые в жизни появляется фундамент.

Современная AI-разработка — это гнев разработчиков, возведённый в систему.

Честно говоря, я задолбался. Нам уже который год рассказывают одну и ту же сказку: «ИИ освободит разработчиков от рутины», «достаточно правильно написать промпт», «будущее за AI-кодингом». А на практике что? Сидишь, жмёшь «сгенерировать ещё раз», смотришь на сгоревшие токены и понимаешь: опять переписывать руками.

И самое обидное — они на этом зарабатывают. Каждый твой запрос — это деньги в их карман. Чем больше ты промптишь, тем больше они получают. Они, гиганты рынка AI-кодинга — большие обманщики.

Я почему-то должен был поверить: ЗА AI ВАЙБ-КОДИНГОМ БУДУЩЕЕ, И ПО КАКОЙ-ТО ПРИЧИНЕ Я ЕЩЁ ДОЛЖЕН ЗА ЭТО ПЛАТИТЬ ДЕНЬГИ!!!

Что за чушь?

В какой-то момент я понял: я работаю не на себя. Я работаю на чью-то токен-экономику. И решил: хватит.

Я уверен, что будущее за DEEP CODING, где за кодинг не мы платим — платят нам!

Дальше я расскажу, как я по шагам вырвался из этой ловушки. Как прошёл путь от «час на двадцать пять компонентов» до «тысячи компонентов в месяц за двадцать долларов». Как перестал платить за каждый чих модели и превратил ИИ из магии, которая иногда работает, в послушный инструмент, который играет по моим правилам.

Без магии. Без «купите наш SaaS». Только честная эволюция одного упёртого разработчика, который устал от обмана.

Этап первый: когда я начал замечать, что модель меня обманывает

Раз за разом, запрос к запросу, я стал обращать внимание на то, как модель на самом деле «думает». Я не пытался писать лучшие промпты и не читал очередные статьи про «как правильно общаться с GPT». Я просто анализировал ошибки.

Модель путала клиентский и серверный код. Генерировала дублирующую логику. Забывала про TypeScript типы. Смешивала всё в одной папке. Каждый раз изобретала велосипед вместо переиспользования существующего.

И постепенно я стал замечать паттерн, который перевернул моё понимание всей этой истории с AI-кодингом: модель не понимает мою архитектуру. Каждый раз она генерирует с нуля, как будто мы только что познакомились. Проблема не в модели. Проблема в том, что у меня не было архитектуры, которую она могла бы понять.

Тогда я решил разбить каждую итерацию кода на фрактал — маленький изолированный блок со своей структурой папок, со своими правилами, с чёткой границей между «вот это фрактал» и «вот это не фрактал». Я начал копировать весь код фрактала в Google Документы, вставлять его в промпт для модели, получать ответ и копировать обратно в Visual Studio Code.

Одну достаточно сложную задачу я успевал сделать за час. Это было примерно двадцать пять компонентов по двести строк кода. С одной стороны, это было долго — копипаст туда-сюда. С другой стороны, это реально работало. Модель перестала забывать архитектуру, потому что я каждый раз скармливал ей весь контекст.

Об этом я писал в прошлой статье. Это был мой первый прорыв. Но я хотел быстрее.

Этап второй: когда я нашёл Perplexity Spaces и всё изменилось

Я начал искать способ не объяснять модели архитектуру каждый раз заново. И тут я наткнулся на Perplexity Pro Spaces — такую недооценённую штуку, о которой почти никто не говорит.

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

Я описал свою фрактальную архитектуру целиком. Слоты @left для системного: чат-бот, авторизация, Stripe. Слоты @rightStatic и @rightDynamic для продукта. Фракталы (_FRACTAL_NAME) всегда с тремя слоями внутри: (_client), (_server), (_shared). Правила: что разрешено, что запрещено, какие лимиты по файлам, как именовать компоненты.

Примеры деревьев фракталов выглядели примерно так:

app
└── (lang)                                              # динамический сегмент языка
    ├── @left                                           # левый слот (система)
    │   ├── (_CHAT)                                     # фрактал чата
    │   │   └── chat
    │   │       ├── page.tsx
    │   │       ├── (_client)
    │   │       ├── (_server)
    │   │       ├── (_shared)
    │   │       └── SPEC.md
    │   │
    │   ├── (_AUTH)                                     # фрактал авторизации
    │   │   └── auth
    │   │       ├── page.tsx
    │   │       ├── (_client)
    │   │       ├── (_server)
    │   │       ├── (_shared)
    │   │       └── SPEC.md
    │   │
    │   └── (_ARTIFACT)                                 # фрактал артефакта
    │       └── artifact
    │           ├── page.tsx
    │           ├── (_client)
    │           ├── (_server)
    │           ├── (_shared)
    │           └── SPEC.md
    │
    ├── @rightDynamic                                   # правый динамический слот
    │   └── (_DASHBOARD)                                # фрактал дашборда
    │       └── dashboard
    │           ├── page.tsx
    │           ├── (_client)
    │           ├── (_server)
    │           ├── (_shared)
    │           ├── SPEC.md
    │           └── (_subfractals)
    │
    └── @rightStatic                                    # правый статический слот
        ├── (_HOMEPAGE)                                 # фрактал главной страницы
        │   └── home
        │       ├── page.tsx
        │       ├── (_client)
        │       ├── (_server)
        │       ├── (_shared)
        │       ├── SPEC.md
        │       └── (_subfractals)
        │           └── (_HEROSECTION)                  # субфрактал hero-секции
        │               └── hero-section
        │                   ├── (_client)
        │                   ├── (_server)
        │                   ├── (_shared)
        │                   └── SPEC.md
        │
        └── (_BLOG)                                     # фрактал блога
            └── blog
                ├── page.tsx
                ├── (_client)
                ├── (_server)
                ├── (_shared)
                ├── SPEC.md
                └── (_subfractals)

И знаете что? Модель перестала выдумывать. Она начала генерировать код ровно по моим правилам. Не по лучшим практикам со Stack Overflow. Не по усреднённой мудрости интернета. По моим правилам.

Этап третий: странный ритуал разогрева чата, который звучит как шаманство, но работает как часы

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

Хочу сразу предупредить: управлять моделью очень непросто. Модель не любит забывать о своём опыте. После третьего-четвёртого-пятого чата, если модель ещё не начала ошибаться, она уже не начнёт ошибаться и будет возвращать хороший стабильный код. Если она начала ошибаться, она будет ошибаться всегда. В таких случаях нужно начать новый чат.

Но самое главное открытие было в другом: первые запросы должны быть лёгкими, как разминка перед забегом. Я перестал сразу просить код. Я начал разговаривать с моделью, как будто пытаюсь понять, проснулась ли она ещё или всё ещё спит.

Привет, скажи, помнишь ли ты мой документ про фрактальную архитектуру? Как ты думаешь, в чём основной фокус этого документа? В документе про слоты мы говорим о том, что @left это система, а @rightStatic это продукт. Как ты это понимаешь? Если я попрошу тебя создать фрактал (_HERO_SECTION), какую структуру папок ты создашь?

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

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

Этап четвёртый: когда я устал таскать код руками и создал артефакт

К этому моменту у меня была фрактальная архитектура, правила в Perplexity Spaces, ритуал разогрева чата. Но я всё ещё таскал код руками: копировал дерево в чат, копировал ответ обратно в VS Code, раскладывал файлы по папкам. Это не разработка. Это офисный спорт.

Я создал на своей платформе специальный инструмент, который назвал артефактом. Он делает всё за меня: читает текущий код фрактала с диска, склеивает промпт с правилами из Space, спрашивает Perplexity внутри нужного пространства, парсит ответ и достаёт файлы, записывает изменения на диск, обновляет SPEC.md с версией, датой и комментарием.

Раньше одна итерация занимала пять минут. Сейчас шестьдесят секунд. Я пишу: «Добавь анимацию градиента в hero-секцию». Артефакт читает фрактал, дёргает Perplexity, раскладывает файлы, обновляет SPEC.md. Готово.

Это не магия. Это просто правильная автоматизация рутины. Но именно она превратила процесс из «копипаст-марафона» в нормальную разработку.

Результат: тысячи компонентов в месяц за двадцать долларов — это не фантастика, это реальность

Сейчас моя система работает как хорошо отлаженный механизм. Один фрактал, например (_HERO_SECTION), это пять-десять компонентов, типы, серверные экшены, переводы на три языка, SPEC.md с полной историей эволюции. Генерация одного фрактала занимает от шестидесяти секунд до пяти минут в зависимости от сложности. За час я могу сгенерировать десять-двадцать фракталов. За день сотни компонентов. За месяц тысячи.

И всё это за фикс двадцать долларов в месяц, стоимость подписки Perplexity Pro.

Давайте сравним с тем, что нам продают. v0 берёт двадцать-тридцать долларов в месяц за двести-триста компонентов, только UI, без бэкенда. Bolt просит тридцать-пятьдесят долларов за пятьдесят-сто компонентов, токены выгорают быстро, код хрупкий. Lovable обещает двадцать пять-сорок долларов за сто-двести компонентов игрушечного кода, который нельзя развернуть как есть.

AIFA с Perplexity Spaces — это двадцать долларов в месяц фиксированно, тысячи компонентов, production-ready код, полный контроль над архитектурой. Это не теория. Это работает прямо сейчас.

Я создал для этого архитектуру, которую назвал AIFA — AI FRACTAL ARCHITECT: бесплатный кодинг, миллионы строк кода, десятки тысяч компонентов, тысячи фракталов, железобетонная устойчивость для настоящих проектов, а не для игрушечных!

Frozen-фракталы и WordPress Marketplace 2.0 — когда разработчики снова начинают зарабатывать на своём коде

А теперь самая сладкая часть. Помните WordPress Marketplace? Когда обычный разработчик мог написать плагин, выложить его в каталог и годами зарабатывать честные деньги? Это была самая честная игра в истории веба: open source, прозрачные механики, разработчики зарабатывали на своём коде, минимум магии и обмана.

Что, если сделать то же самое с фракталами?

Frozen-фрактал — это фрактал, который прошёл путь от Minimal до Improved, обкатан, стабилизирован, заморожен как готовый артефакт. Ты можешь подключить его в проект за секунды: он встаёт в нужный слот @rightStatic или @rightDynamic, сразу компилируется. Можешь обновлять по версиям, не ломая контракты, всё фиксируется в SPEC.md.

В конфиге проекта есть специальный слой-реестр, где перечислены frozen-фракталы как плагины, указано где они монтируются в какой слот, настроены фичи какие блоки включены или выключены. Это как темы и плагины в WordPress, только для фракталов.

Уже в январе две тысячи двадцать шестого года я покажу следующий шаг эволюции: когда Perplexity Pro превращается не просто в умный чат, а в площадку для заработка на своих фракталах. Как когда-то WordPress Marketplace, только в современном стеке, с AI-первым подходом, с честными правилами.

Пока это звучит сложно и примеров мало, но я над ними работаю. Скоро всё увидите: https://aifa.dev и https://github.com/aifa-agi

А почему именно aifa-AGI? Спросите в комментариях, если интересно. Там своя философия.

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

Ребята, давайте честно. Нам продают подделку. Игрушечный код вместо архитектуры. Каждый запрос минус деньги. Мы бесплатно тестируем чужие SaaS-платформы, а они зарабатывают на нашей боли и усталости.

Однозначно нужно всё это поменять.

Мы не обязаны в этом участвовать. Мы можем играть в другую игру. Построить свою архитектуру с фракталами (_FRACTAL_NAME), тремя слоями (_client), (_server), (_shared), слотами @left, @rightStatic, @rightDynamic. Использовать Perplexity Spaces как базу правил, которая никогда не забывает. Автоматизировать рутину через артефакт. Зарабатывать на своих фракталах через frozen-фракталы и маркетплейс.

Если вы устали от вау-демо и хотите строить по-настоящему, заведите Space, опишите свои правила, разделите проект на фракталы, посмотрите как модель ведёт себя когда у неё впервые в жизни появляется фундамент.

А дальше может быть мы вместе дойдём до архитектур где ИИ наконец-то работает на разработчика а не наоборот.

Это не маркетинг. Это слёзы облегчения.

Это восстание разработчиков.

Это был момент, когда я понял: я могу контролировать ИИ. Впервые за всё это время я почувствовал, что не я работаю на модель, а модель работает на меня.

Если вам кажется, что всё это звучит слишком сложно — я вас понимаю. Когда я сам начинал, я думал точно так же. Но знаете что? Самые мощные инструменты всегда кажутся сложными, пока не попробуешь их руками.

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

npm install aifa

Просто установите пакет в своём проекте. И всё. AIFA сама развернёт базовую структуру: параллельные слоты @left и @rightStatic, первый фрактал с тремя слоями, SPEC.md, примеры конфигов для Perplexity Spaces, шаблоны для артефакта. Вам не нужно будет разбираться в философии фракталов или читать сотни страниц документации перед первым запуском.

Вы просто запускаете npm install aifa, и архитектура, на создание которой у меня ушли месяцы боли и экспериментов, разворачивается у вас за минуту. Дальше вы уже сами решаете: хотите изучить глубже — добро пожаловать в документацию. Хотите просто начать генерировать код — вперёд, всё уже работает из коробки.

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

Барьер входа будет таким же низким, как когда-то у WordPress: скачал, установил, начал создавать. Только вместо блогов на PHP — production-ready приложения на Next.js с AI-первой архитектурой.

Первого января. Бесплатно. Навсегда открыто.

Чтобы не пропустить запуск и все обновления — подписывайтесь на меня здесь, на Хабре. Я буду регулярно делиться кейсами, показывать живые примеры фракталов, рассказывать про новые фичи AIFA и про то, как маркетплейс frozen-фракталов превращается из идеи в работающую площадку.

Теги: #Сезон ИИ в разработке, #Perplexity, #Next.js, #AI-coding, #fractal-architecture