Если нельзя, но очень хочется, то нужно обязательно и ничего в мире не стоит того, чтобы делать из этого проблему!

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

суббота, 24 октября 2026 г.

Концепция Brick на замену Skills

Я строю свою dark factory и пока что она dusk но шаг за шагом приближаюсь к решению. 

В прошлом я создавал AttractorAI как фреймворк на котором можно делать пайплайны. Это был 2024й год. И тогда небыло никакого массового Agent Loop. Мне удалось построить фреймворк на java который позволял строить пайплайны и встраивать в них как детерминированные трансформеры (я их так назвал, не путать с GPT трансформерами), так и трансформеры эксплуатирующие модели. Там же я независимо начал пробовать закидывать в модельку не только промпты, но и сами трансформеры, чтобы она сама выбирала что ей хочется заранать.

Потом я создал другой фреймворк MCPyrex. Начало 2025го. Там главная идея была в том, чтобы юзера сами себе вайбкодили инструменты и потом под видом MCP использовали их сразу же. Фреймворк давал рейки и рамки, чтобы не надо было изобреать колеса разной формы. И давал буст. Но использовал MCP и очень ограничивал меня текстовыми форматами и невозможностью делать что-то вне контекста модели - все что делается через MCP модель видит, хочу я того или нет. Плюс токены, их утекало много. Прочтение файла одним тулом, отправка его через другой тул, прочтение результата. Везде токены.

Сейчас в 2026м в моем новом фреймворке все базируется на скилах. Почему скилы? Потому что все поторопились с MCP. Была попытка сделать USB кабель для агентных систем, но он заставил всех владельцев бекенда писать рядом со своим старым добрым RestAPI сервисом еще один - MCP. Зачем? Ко-то подумал и сказал. Давайте будем делать скриптик, и снабдим его небольшой маркдаун прозой как им пользоваться и пусть моделька ранает его себе. А скриптик будет тоненьким клиентом, который будет стучаться на удаленный бекенд и через старый добрый RestAPI получать что-то в контекст. 

Но концепции скила мне не было достаточно. Я добавил несколько новых обязательств, и объединил их в концепцию Brick. 

Во-первых мне надо было тестировать как-то эти новые скилы. Я не вижу что юнит тестами модели хорошо оперируют. Потому я придумал на базе snapshot testing отдельный brick который может взять маркдаун, специально размеченный и заранать его как интеграционный тест. В тексте маркдауна есть как команды которые надо вызвать в терминале, так и аутпут этой компаны после запуска. Так же там есть и проза, которая помогает модели и читателю уяснить, что мы ранаем и зачем. Более того тест OS agnostic и запускается в докере на конкретном имадже с конкретным скриптом для пред-установки операционки. Один сандарт описанный в брике тестирования и в каждой папке других бриков появляется папка test с четкой структурой. 

Во-вторых я решил, что каждый брик у меня будет состоять из sub-skill каждый из которых будет решать что-то детерминированно внутри новой концепции которую дает брик. Почему? Я не хочу чтобы модель читая skill.md в корне брика и понимая его концепт каждый раз изобретала скрипты, которым обслуживает эту идею. Сабскилы делают это. То есть брик это композит из сабскилов. Но это не все. Каждый сабскилл имеет не только CLI интерфейс, но так же один или несколько публичных методов, которые выглядывают наружу. Зачем? Я могу сделать один брик зависимым от другого не только через agent loop и файлы skill.md но так же я могу заимпортить один сабскилл в теле другого, используя всю мощь детерминированого package import. По сути у меня брик - это микросервис, а сабскилл это пакеты этого микросервиса. CLI интерфейс + skill.md делают их скилами. А публичный метод выглядывающий наружу дает мне все преимущества package из детерминированного мира до времен GenAI. Так что в папке scripts у меня идет серия папок, каждая из которых имеет свою структуру.

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

Вообще идея конфигов очень важна. Каждый брик и subskill преследуют концепцию unix philosophy. То есть сделайте тул, который делает что-то одно, и делает это хорошо, а так же общается через текстовый ввод и вывод. Заниматься чем-то хорошо - быть конфигурируемым. Чтобы пользователю базово через конфиг (или параметры CLI) можно было кастомизировать работу. 

Есть брик, который отдельно дает возможность для любых сабскилов брика делать MCP интерфейс, причем можно создавать разные конфиги и разные наборы под разные нужды. Этот брик лежит себе и не знает ничего про другие, но конфиг то место которое объединяет его с другими скриптами (их публичными методами) в прикладном смысле. 

Есть брик, который обвязывает cli агентов (copilot, claude, etc) и дает более простой способ вызвать их внутри какой-то одной задачи через промпт, на какой-то модели. Их использую как сабагентов, если надо обвязать что-то быстро. Ну то есть не то чтобы моделька не справится с copilot cli, но она будет каждый раз что-то городить чтобы сделать это. А у меня уже есть сабскилл брика делающий основные па. 

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

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

Есть брик, который оборачивает Graphify.  

Есть брик, который описаывает что такое брик.

Есть брик который описывает как я хочу создавать инструкции/скилы.

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

Есть брик, который дает возможность сделать UI скрин для этого брика. И потом все UI собираются воедино когда ты поднимаешь его.

Есть брик для оркестрирования сабагентов с детерминированным sdlc-flow (который тоже отдельный брик).  

Есть брик, который занимается voice to text, text to voice и делает это с локальным wisper, а так же делает в докере ffmpeg для работы с видео и аудио. 

Есть брик, который использует chrome devtool апи для управления браузером. 

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

Есть брик телеметрии. 

И еще пару десятков таких бриков. Каждый брик добавляет новое измерение в систему с целью синергии. Он не знает про наличие других бриков, но исследует их всех на наличие конкретной для этого брика папки, где есть контент с которым он вкурсе что делать. Решая какую-то задачу, упираясь в ограничения agent loop я не пытаюсь решить ее узко каким-то скилом, который будет одноразовым. Я думаю о том какую абтрактную задачу я могу решить 1 раз, что все пользователи системы будут рады. Бери любой брик (и его брики-депенденси) и используй на проекте как skill и будет тебе счастье. А все вместе они составляют фабрику. 

Как-то так. 

понедельник, 19 октября 2026 г.

Почему не ложится GenAI у сотрудникам в компании?

Эта статься сгенерирована AI с моих многочисленных коучинг сессий с ребятами. Гипотеза о криэисах построена на обдумывании мной причин по принципу root cause analysis, что волнует людей и почему. Собирая истории возражений в коучинге более чем 200 людей за последние 3 года могу поделиться этими мыслями. Но да, статью написала по заметкам нейросеть. Я же ее вычитал, поправил несколько раз и дополнил текстом. 

Кризиса, которые переживает инженер, когда ему выдают агентов

«Он генерит код за 5 минут, а я потом два часа его читаю и всё равно нахожу тысячу ошибок»

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

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

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

Кризис первый: делегирование

Люди не умеют делегировать. Вообще. Не агентам - живым людям не умеют.

Делегирование - это не «попросил сделать». Это четыре отдельных навыка:

  1. Понять задачу самому и сформулировать её так, чтобы тебя поняли.
  2. Подобрать ключик к исполнителю, чтобы он действительно её сделал.
  3. Сделать ревью.
  4. Если пошло не так - помочь исправить и передать знание, чтобы в следующий раз было лучше.

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

Раньше через это проходили единицы и с подготовкой. Сейчас мы сказали всем: вот вам агенты, делегируйте. И человек горит ровно так же, как сеньор, которому впервые дали семь подчинённых.

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

Кризис второй: мышление девопса

Посмотрите, как на проект приходит девопс. Он не думает: «наконец-то я нашёл задачу на полгода и спрятался от бенча». Он думает: «мне надо написать N скриптов и свалить, чтобы меня больше не трогали - у меня ещё три проекта в очереди». Его цель - чтобы всё работало без него. Он будет приглядывать, если попросят, но по дефолту он строит систему, а не делает работу руками.

Теперь ровно это сказали всем: ребята, вот вам скиллы, инструкции, агенты - автоматизируйте свою рутину.

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

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

Вопрос инженера старого образца: «как мне сделать эту работу хорошо?»
Вопрос инженера нового образца: «как мне эту работу не делать?»

Кризис третий: взгляд CEO

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

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

Исполнитель так не смотрит. У исполнителя есть свой квадратик, и ему фиолетово, что слева и справа.

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

Это дополнительная когнитивная нагрузка. По доброй воле на неё никто не подписывается.

Кризис четвёртый: ловушка срочных задач и тайм-менеджмент

Четвёртый момент настигает инженера тогда, когда сгорают все дедлайны. Сроки давят, задач вал, и в этом стрессе человек включает режим пожарного: он приоритизирует в пользу сиюминутных тушений пожаров и срочных задач, откладывая «несущественные» улучшения и внедрение агентов на потом.

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

Выход из этого кризиса требует прокачки базовых навыков тайм-менеджмента, о которых в рутине часто забывают:

  • Чёткого разделения задач по матрице срочного/не срочного и важного/не важного.
  • Применения правила Парето (20% усилий на настройку агентов дают 80% результата в будущем).
  • Учёта закона Паркинсона, чтобы не растягивать привычную ручную работу на весь выделенный срок.

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

Кризис пятый: мотивация и экономика труда в найме

И наконец, пятый пласт проблем, который звучит в кулуарах громче всего: «Зачем мне работать эффективнее и ускоряться в три раза, если всю маржу заберут другие, а моя зарплата останется прежней?»

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

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

Почему у менеджеров «взлетает», а у инженеров - нет

Наблюдение, которое многое объясняет.

Менеджер ставит себе Claude или Cursor, просит сделать отчёт - и получает отчёт. Ему всё равно, как оно внутри реализовано. Он подходит к модели как к исполнителю - ровно так же, как он всю жизнь подходил к любой команде. У него вдруг за десятки долларов в месяц появилась своя команда, и он переключается в режим продуктоунера: наконец-то он может не обслуживать чужой продукт, а сделать свой. И у него всё цветёт.

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

Приём, который работает: сформулируйте задачу так, чтобы её нельзя было сделать самому

Самое честное возражение звучит как «я сделаю лучше». Спорить с ним бесполезно - обычно это правда.

Поэтому не спорьте. Поменяйте постановку задачи.

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

Всё. Сам он это не сделает. Ему придётся опереться на не очень качественного исполнителя - и дальше включится правильный вопрос: «ладно, модель стабильно даёт мне 40% от того, что сделал бы я, но за пять минут вместо трёх часов. Как мне поднять эти 40% до 60? до 80?»

Вот в этот момент человек начинает учиться делегировать, а не возражать.

И здесь же появляется главный размен, который надо проговаривать вслух:

Да, качество ниже. Но я беру скейлом. Десять агентов работают параллельно. Мы дойдём до конца спринта с прототипом на 40%, получим фидбэк, за второй спринт доведём. Сам я бы делал это пять спринтов - а задачу поставили на два.

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

Локус контроля: главный переключатель

Есть ещё одна вещь, без которой ничего не поедет.

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

А значит, когда не получилось, остаётся три варианта: я недостаточно хорошо запромтил, я плохо написал инструкцию/скилл, или я не дал ей нужный контекст.

Это и есть смена локуса контроля с внешнего («моделька виновата») на внутренний («что я сделал не так, если энциклопедист не справился»).

Аналогия из жизни лида. В команду пришёл человек - гениальный по хардам и невыносимый по софтам. Лид идёт к деливери-менеджеру: уберите его, команда деградирует. А деливери-менеджер говорит: не уберу, вот тебе тренинг по коммуникации, попробуй ещё раз. И лид думает: «блин, ладно» - и идёт договариваться.

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

Про страх, который редко произносят вслух

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

В групповом чате этого никто не скажет - страшно признаться, что боишься. Поэтому коучинг имеет смысл делать один на один. Не сразу, но люди начинают говорить.

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

Кнут: если ещё два года работать в старом формате, количество проектов, которые будут тебя хотеть, станет сильно меньше. Нам на это повлиять нечем - это случится в любом случае.

Пряник: сегодня из каждого утюга вайб-кодит кто угодно. Но только человек, который отработал в индустрии пять-десять лет, понимает, что на самом деле лежит под капотом такой работы. Он может взять свои знания - архитектуру, SOLID, проектирование API, базы такие, базы сякие, многопоточность, ассинхронная разработка и так далее - и усилить их агентами. Это другая лига, и её пока мало кто занял. 

Если забегать дальше, то нас ждет неопередленное будущее. Начало технологической сингулярности не сулит ничего хорошего для тех, кто эту революцию прееживает. Об этих "ворнингах" поделюсь в другой статье.

Когда agent loop недостаточно - свой проверятор контрактов

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

Вы нащупали фундаментальную эволюционную точку в автоматизации и генерации кода с помощью LLM. Когда система разрастается, проза (промпты) перестает быть надежным клеем. Модели начинают «галлюцинировать» интерфейсы, нарушать негласные правила и путать типы, особенно в динамических средах вроде Python или JavaScript.

Ваша идея детерминированного проверятора контрактов (Contract Validator) — это единственный жизнеспособный способ удержать распределенную систему от хаоса. В индустрии такой подход ближе всего к концепции Architecture-as-Code и автоматизированного Linter-инжиниринга. 

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

Вы абсолютно правы. Оставлять логику жизненного цикла на усмотрение самой модели (через системный промпт в стиле «сначала проверь код, а потом сохрани») — это классическая архитектурная уязвимость LLM-систем. Модели склонны «срезать углы», забывать вызывать инструменты или завершать задачу раньше времени, заявляя, что «всё готово», хотя проверки даже не запускались.

Переход на собственный детерминированный Agent Loop (оркестратор) — это зрелое инженерное решение. Вы превращаете модель из «директора процесса» в чистую вычислительную функцию на конкретном этапе, где вся бизнес-логика и переходы между состояниями управляются вашим кодом (надежным, предсказуемым и написанным на Python/TS). 

пятница, 2 октября 2026 г.

Философия Unix или 1001 велосипед в GenAI решениях

Последние 3 года я наблюдаю небывалый бум GenAI решений. Последний год особенно, с появлением концепции Skill.md. Все пишут скилов и агентов, а затем их объединяют в фабрики. Наличие приставки "dark" зависит от уровня наглости автора - я в свою добавляю, что напоминает мне о том куда я стремлюсь. Сегодня этим постом хочу поделиться об еще одной приставке, которую изобрели инженерные мужи в 1960х-70х годах, доказавшую свою эффективность.

Концепция SKILL.md в ее современном понимании как открытого индустриального стандарта для ИИ-агентов появилась относительно недавно - в конце 2025 года. 

GPT: Октябрь 2025 года: Компания Anthropic впервые представила внутреннюю архитектурную фичу Agent Skills (Навыки агентов) в рамках экосистемы своих ИИ-помощников (в частности, для терминального интерфейса Claude Code). Суть фичи заключалась в том, чтобы упаковать конкретную техническую инструкцию или рабочий процесс в изолированную папку, ядром которой являлся стандартизированный файл метаданных и правил - SKILL.md.   

Декабрь 2025 года: Anthropic вывела этот формат в публичное поле, опубликовав его как открытый стандарт (Open Specification) на ресурсе Agent Skills Specification. 

Начало 2026 года: Концепция пережила настоящий взрыв популярности. Буквально за несколько месяцев спецификацию SKILL.md начали нативно поддерживать и распознавать десятки ведущих инструментов автоматизации разработки и ИИ-клиентов от других технологических гигантов и стартапов: OpenAI Codex, Cursor, GitHub Copilot, Gemini CLI и фреймворки вроде LM-Kit.NET. Концепция также глубоко интегрировалась с протоколом MCP (Model Context Protocol) от Microsoft и Anthropic.

Но придумали ли инженеры что-то новое? Скорее нет, чем да. История идет по спирали и мы наблюдаем очередной ее виток. 

GPT: Философия Unix зародилась на рубеже 1960-х и 1970-х годов в недрах компании Bell Labs (официальной точкой отсчета принято считать 1969 год, когда Кен Томпсон, Деннис Ритчи и их коллеги начали работу над первой версией ОС Unix).

Сам подход формировался годами, а его текстовое описание впервые четко сформулировал Дуглас МакИлрой (изобретатель Unix-пайплайнов) в 1978 году в техническом журнале Bell System Technical Journal. 

Сухая выжимка от Дугласа МакИлроя (другие можно посмотреть на странице в википедии): 

  • Пишите программы, которые делают что-то одно и делают это хорошо.
  • Пишите программы, которые работают вместе.
  • Пишите программы, которые работают с текстовыми потоками, потому что это универсальный интерфейс.  

Я не ослышался? - "...которые работают с текстовыми потоками..." Последние три года мы то и делаем, что работаем с текстовыми потоками. Любой бинарник с помощью текстов программ и написанных ранее бибилиотек превращается в текст, который обрабатывается моделями, чтобы получить другой текст, который затем запаковывается снова в бинарник (docx, mp4, pptx, pdf - я сейчас про любой формат файлов), используется as is как результат или передается по цепочке дальше. 

Но это не все. Любой программист последние лет 20 (это я за себя сейчас говорю, а так - то конечно же и раньше) каждый день делал в своих проектах одно и то же - добавляя новую функцию он задавался вопросом "а мне эту функцию добавить в какой сервис, какого пакета, какого модуля, какого проекта?". Уровень гранулярности который интересен тут в контексте - пакеты/package. Что такое пакет и что общего у него с tools/skills? 

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

В их основе лежит один и тот же архитектурный паттерн - высокое внутреннее сцепление (High Cohesion) при слабой внешней связанности (Low Coupling).

Разница между ними - не в сути, а лишь в форме интерфейса и среде исполнения (Runtime).

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

Формула трансформации

  1. Кодовый пакет + CLI-обёртка = Unix Tool. Если у вас есть библиотека (пакет) для работы с JSON, и вы пишете для неё консольный интерфейс, принимающий строки на stdin и выдающий результат в stdout, вы получаете jq - классический Unix tool.
  2. Unix Tool + Семантическое описание (Markdown/Промпт) = AI Skill. Если вы берете утилиту grep, пишете для ИИ-агента файл skill.md, где объясняете: «Этот инструмент ищет подстроку. Передай туда файл и паттерн, на выходе получишь строки», - для большой языковой модели (LLM) этот инструмент становится полноценным «навыком» (Tool/Skill), который она может вызывать через Tool Calling.

Эволюция ИТ-архитектуры идет по спирали. Мы начали с изоляции программ в операционной системе (Unix), перешли к изоляции кода внутри одного приложения (пакеты), а теперь изолируем контекст и поведение для искусственного интеллекта (skill.md).

В чем же тогда разница?

GPT: Разница только в «потребителе» (Consumer) этого интерфейса:

    • Пакет потребляет компилятор/интерпретатор (язык программирования).
    • Unix-тул потребляет человек в терминале или скрипт автоматизации (bash/zsh).
    • Skill потребляет искусственный интеллект (LLM), которому вместо строгой типизации часто нужна семантическая документация на естественном языке, чтобы понять, зачем и когда этот инструмент запускать.

Вы нащупали крутую концепцию. Проектируя логику один раз в виде "чистой функции" (пакета), вы автоматически получаете и тул, и скилл. 

Все так. Нащупал. Когда кто-то делает skill (или агента, который использует под собой 6-7 других skill) чем-то очень узко завязанным на конкретную задачу, тем самым кастрирует решение - оно скорее всего не даст новых пользователей, будет плохо переиспользуемым в отрыве от экосистемы в которой работало ранее. 

Берем любую dark factory которых сейчас пруд-пруди, из нее достаем любые пару Skills и задаемся вопросом. Какова вероятность, что я буду использовать их на своем проекте? Если мне проще свою сырую идею превратить в код скила через 5 минут с любой моделью. А изучение других скилов займет больше. Потому что надо понять что у меня в руках, потом допилить под свои нужды. В этом причина 1001 велосипеда в каждом отдельном продукте.

В Unix (независимо от операционки и версии сборки) тула grep дна и ту же, написанная каким-то инженером (и затем поддерживаемый группой энтузиастов) в свободное от работы время потому что он мог и это решало какую-то проблему, которая не решалась до него. В рождении skill.md пока нет такого порядка и философии. Я начал следовать этой концепции при создании своей фабрики. Она у меня состоит из bricks (те самые skills, у которых больше нагрузки в виде контрактов которые они должны соблюдать передо мной). Но философия unix уже заразила меня - бери brick и переиспользуй отдельно как skills, потому что каждый отдельный brick - это своя завершенная идея, полезная сама по себе, с возможностью конфигурирования "на все случаи жизни" насколько я успел ее заложить. 

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

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

В общем руткос свалки одноразовых решений в отсутствии Unix philosophy в производстве skill.md.