Сел тут выписывать категории стейкхолдеров. В проекте положено делать анализ стейкхолдеров, да? Обычно его либо не делают, либо с умным видом рассказывают про "луковичную диаграмму" (и иногда даже рисуют её).

Луковичная диаграмма делит стейкхолдеров на круги, или слои. Конкретные названия слоев варьируются.

Йэн Александер (собственно, автор методики и книг «Writing Better Requirements» и «Discovering Requirements: How to Specify Products and Services» — кстати, не вижу, чтобы они переводились на русский, а это вам не Вигерс, это конкретное руководство про выявлению и написанию требований) предлагает следующие:

0 слой: сам продукт
1 слой: "наша" система: продукт + операторы + инструкции/правила по работе с системой
2 слой: объемлющая (содержащая) система: наша система + бенефициары нашей системы (кто получает пользу от её функционирования, но сами могут не пользоваться ей)
3 слой: широкое окружение: объемлющая система + все остальные стейкхолдеры

Раскладывает стейкхолдеров по типам так:
1 слой ("наша система"):

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

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

* Операционная поддержка: так как система включает технику и людей, должно быть две роли — поддерживающая технику и поддерживающая людей. Это может быть служба поддержки и люди, занимающиеся обучением.

2 слой ("содержащая система"):

* Функциональный бенефициар. Получает пользу от нашей системы, возможно не напрямую, а от операторов. Это немного старомодное деление, когда умение работать с компьютерами было отдельным скиллом. Хотя встречается и сейчас, в любом взаимодействии, когда вы смотрите на экран компьютера с обратной стороны: на кассах, в банках, МФЦ и т.п. Функциональный бенефициар в данном случае мы, мы взаимодействуем с оператором, а не с системой напрямую.

* Владелец смежной системы. Александер называет их "Ответственными за интерфейсы". С кем вы будете говорить, когда речь пойдет об интеграциях.
* Приобретатель. Может быть один (в организации) или миллионы (в массовом продукте, тогда их представляет Продакт). Кто выкладывает денежки. Кто отвечает за то, чтобы продукт был сделан.
* Спонсор или чемпион продукта. По-русски мы так не говорим, но это тот, кто вообще пробивает создание нашего продукта. Причем не только находит деньги но и решает политические вопросы. Исполнительный продюсер.

3 слой ("широкое окружение"):
* Негативный стейкхолдер. Тот, кто может пострадать от внедрения системы: физически, финансово или иным способом, за который вы будете отвечать перед регуляторами или судом. Требования регуляторов на самом деле — формализованные и обобщенные требования негативных стейкхолдеров (или ограничения). Александер добавляет сюда же стейкхолдеров, которые могут пытаться вредить работе продукта.

Он даже предлагает выделять специальную роль:

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

* Политический бенефициар. Кто получит выигрыш с точки зрения власти, влияния или престижа от создания вашей системы? Мой любимый тип стейкхолдеров. Пользоваться системой они не будут, может быть даже функциональными бенефициарами не будут, а вот власть и влияние их очень интересуют. В государственных организациях (и некоторых крупных бизнесовых) это чуть ли не основной смысл существования некоторых систем, а за контроль над ними ведутся жестокие битвы. Политические бенефициары могут быть и негативными — активно противодействовать созданию систем, или создавать свою альтернативную, или запрещать/затруднять интеграцию. Чем выше вы заходите в управление корпоративными продуктами, тем больше там политики.

* Финансовый бенефициар. Получит прибыль от создания системы. По-честному, редко берется в расчет, если вы не делаете коммерческий продукт.

* Регулятор. Тот, кто задает правила игры — обычно в виде ограничений или навязанных функций.
* Разработчик. Есть мнение, что они вообще не должны быть в этой модели, они перпендикулярны.
* Консультант (западная практика, бывает ли в РФ?)
* Поставщик (обычно очень далекая роль, но для некоторых систем бывает крайне важен)

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

Дальше культурно-историческая теория деятельности (в изложении Энгестрема) говорит о противоречиях — contradictions, или о напряжениях — tensions. Зачастую эти противоречия уже существуют, сложились исторически ещё до внедрения ИТ-системы, а система может их гасить или усугублять, или вводить новые напряжения.

Эти же напряжения являются на самом деле движущей силой для эволюции системы деятельности, в том числе для создания ИТ-систем. Интересный вопрос — какое напряжение, какое противоречие стало поводом создать вашу систему?

Энгестрем выделяет структурно 4 уровня противоречий:

1. Противоречие в одном узле деятельности: например, правила противоречат друг-другу, или инструменты несовместимы/делают принципиально разное, в разделении труда одна задача назначена двум ролям, у деятельности несколько разных объектов и целей.

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

3. Противоречие между существующей системой деятельности и новой. Это когда мы пытаемся что-то менять.

4. Противоречие между смежными системами: теми, что соединены через общий результат, теми, кто пользуются результатом, кто дает вам правила, инструменты, сообщества, да и самих субъектов (привет, HR!)

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

У противоречий есть 4 проявления:
1. Дилемма
2. Конфликт
3. Критический конфликт
4. Двойное послание

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

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

Впрочем, это оптимистичный взгляд — бывает и по-плохому:
* система деятельности может застрять в бесконечных воркэраундах, а люди начнут просто сгорать из-за двойных посланий;
* сообщество может фрагментироваться и поляризоваться: все начнут обвинять друг-друга, и без способности объединиться никакого обучения происходить не будет, а будет происходить политический паралич;
* руководство (особенно бюрократическое) может начать усиливать давление: раз правила не работают, значит, их плохо соблюдают. Давайте введем больше правил и строже штрафовать! Система сваливается в раскручивающуюся петлю обратной связи
* вместо усложнения деятельности система может деградировать и вернуться к более простым, но энергетически более выгодным формам

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

Знаю, что в Яндексе работает много аналитиков данных, или BI-аналитиков — тех, кто перемалывает массивы данных и извлекает из них всякие интересные инсайты.

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

У Яндекса есть подкаст от аналитиков для аналитиков "Доверительный интервал" — это регулярные встречи, где они обсуждают свои задачи и актуальные боли. Последний выпуск там был про ИИ: у них тоже идёт освоение, adoption, есть сомневающиеся, есть и ментальные блоки "ой, я попробовал, ничего эти агенты не умеют".

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

Интересная мысль там была про агентов. Я сам где-то с весны работаю не в отдельных чатах, а в Cursor'е. Какие там агенты, где там агенты — ну, где-то внутри они есть, для меня это всё равно выглядит, как чат. Но! Этот чат (через агентов) имеет доступ к файлам на диске, к браузеру, к интерпретатору python или node, MCP, и может запускать разных агентов для разных задач. Если вы видели ИИ только в виде чата в браузере — попробуйте. Это вообще другой уровень. Те же презентации агентами гораздо удобнее собирать, в чате у меня ни разу нормально не получалось, а тут один агент думает над содержанием, другой пишет код, генерирующий pptx, и запускает его, третий думает про оформление, четвертый проверяет. А когда у вас есть подключенные системы и данные, всё вообще начинает выглядеть, как магия.

В том числе и для пользователей. Я помню, как давно зрела идея, что бизнес сам сможет получать нужные данные. SQL продвигали под этим соусом, конструкторы дашбордов — ничего не срабатывало, всё равно заказчику нужно было или звать разработчиков/аналитиков, или самому становиться таким разработчиком. И вот, наконец, с ИИ — вроде начало получаться. Можно сказать, чего ты хочешь, и ты получишь это. НО! Проблема в том, чтобы убедиться, что данные достоверны. Вот это сомнение важно в заказчика заложить (и ребята в видео как раз об этом говорят), а то часто все принимают на веру.

Куда в таком случае деваются аналитики, и нужны ли они? Ну, во-первых, остаются всё-таки сложные задачи (которые всё равно теперь можно делать в разы быстрее); а, во-вторых, и это даже важнее — аналитики становятся архитекторами инфраструктуры. Чтобы ИИ всё сделал, нужно ему подготовить качественные данные (и убедиться, что они качественные), описания этих данных (чтобы понял смысл) и ограничители/валидаторы (харнесс), чтобы быть уверенными, что ИИ выдал не ерунду.

И это интересное свидетельство о том, какие формы применения ИИ зарождаются в индустрии: 1) усиление себя, делегирование своих задач, получая ускорение в разы или даже десятки раз; 2) передача своих функций заказчикам, оставляя за собой построение архитектуры и контроль качества. Две разных стратегии, но в обеих получается делегирование, только разное — ИИ-агентам или своим же заказчикам. А вы посередине, как царь горы 🤩

Должен вам сказать, на самом деле я не отношусь к ранним последователям. Я даже скорее тормоз в этом смысле. Вот и с ИИ я только весной этого года добрался до Cursor. И вот что советую: если вы пробуете что-то делать в свой работе через чаты — бросайте эту ерунду. Это работает только в режиме "спросить что-то очень быстро" или "сгенерить очередную одноразовую картинку". Для настоящей работы над сколь-нибудь большим проектом нужно использовать среду разработки со встроенными агентами — Cursor, Claude Code, OpenCode и т.п.

Мне нравится Cursor, потому что у него знакомый интерфейс VSCode (и интерфейс в принципе есть, а не просто консоль, я не консольный чувак), есть выбор из разных моделей и встроенные агенты. Это не вайбкодинг, это так сейчас программирование выглядит. Я, кстати, впервые с 2012 года взялся за написание чего-то большего, чем скрипт для анализа или парсинга данных, и сейчас в одиночку строю проект, на который раньше понадобилась бы команда из 3-5 человек.

В принципе, мне даже хватает встроенных в Cursor агентов, но есть несколько скиллов, которыми я активно пользуюсь. Скиллы — это ещё один аргумент к использованию ИИ в таком варианте, а не в онлайн-чате. (Другой — что можно закинуть кучу документов в проект, и не париться ограничениями, агент их сам найдет и изучит, сколько бы их у вас там ни было).

Что у меня из скиллов в постоянной работе:

grill-me от Matt Pocock (https://github.com/mattpocock/skills). Скилл делает ровно то, что в названии — качественно прожаривает вашу идею, иногда прямо очень жестко. Работает он в режиме интервью, то есть задает вам вопросы. Аналитика, который бы задавал такие вопросы, любой заказчик сам бы прожарил из огнемета. А когда они исходят от тупой машины, вроде и не так обидно. На выходе получается план проекта с основными техническими решениями (grill-with-docs формирует документацию, в которой, в том числе, задан язык, которым вы описываете проблемную область). У Мэтта там целый пак скиллов, которыми можно дальше генерить проект по спеке после прожарки, но я использую в основном для обкатки идей проектов и документов.

spec-kit для Cursor (https://github.com/madebyaris/spec-kit-command-cursor). Вы знаете, какое самое последнее новшество в разработке? SDD — Spec-Driven Development, разработка, управляемая спецификациями. Вот неожиданность, правда? Оказывается, ИИ лучше всего разрабатывает по детальным спецификациям, вот так новость! Скиллы от Мэтта — это тоже SDD, но я пока не придумал, как их объединить. SpecKit хорош тем, что содержит цельный воркфлоу, от написания этих самых спецификаций до их реализации. Он тоже сначала проводит с вами интервью, но более поверхностно, без прожарки. Если мне не нужно сильно вникать, я беру его. Он генерит большие объемы спецификаций (сотни задач), а потом так же неутомимо их реализует. Фактически, это таск-трекер на основе файлов, со статусами и ссылками на спецификацию (у меня в одном из проектов оно сделало сходу 61 задачу, и это только MVP!)

adversarial-editorial-review (https://github.com/Halfofthesky/adversarial-editorial-review) — это тоже прожарка, но для статей (очень мне помог при написании магистерской, правда результата от людей-ревьюверов я пока не видел 😅). Он берет ваш текст и дает трем разным "ревьюверам": один считает, что доказательная база слабее, чем вы преподносите, второй — что в аргументации есть логические изъяны, третий — что вы упускаете точку зрения кого-то из вовлеченных лиц, или слишком вольно трактуете теорию, на которую опираетесь. Для научных публикаций мне очень понравился (хинт: можно не только свои брать, но и чью-то готовую опубликованную подсунуть!), нужно бы такой сделать для проектных аналитических документов — чтобы с разных сторон критиковали, а потом редактор сводил общий результат.

В общем, это всё совершенно другой уровень качества, и если вы пробовали только чаты — советую попробовать и такой инструмент (в бесплатной версии он позволяет пощупать, но токены очень быстро кончаются). Я уже включил в свои ежемесячные расходы подписку, ну что же теперь делать, отказываться от этого инструмента не хочется (и, честно говоря, за многие задачи я бы просто не взялся без него).

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

В российских компаниях пока видел, как измеряют число обращений к локальным моделям, развернутым в контуре компании (только к локальным! никаких облачных провайдеров!), число вызовов определенных скиллов. Ну да, для локальных моделей число токенов не так важно, свои же.

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

Я тут исследовал образовательные организации, и как в них внедряют ИИ. Там у них всё жестко и безальтернативно — если уж руководство решило использовать генеративный ИИ, так будут такие методы: планы развития и отчеты о работе теперь принимаются только в виде ссылок на чат с ИИ, в последнем случае — с навыком расчета премий. Вот сколько тебе ИИ рассчитал, столько и получишь. Туда же — планы занятий, генерация репортов об успехах учащегося. Мимо ИИ их просто запрещено делать. На некоторых дисциплинах в качестве ответа на задание от группы принимается тоже ссылка на чат (там, где раньше попросили бы презентацию).

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

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

А как у вас это устроено? Добровольно ли применение ИИ? Есть ли метрики и KPI? Есть ли безальтернативное и обязательное использование инструментов? Или наоборот всё запрещено до сих пор?

Короткая заметка: ещё весной я проводил курс по применению ИИ для системных аналитиков. Ну и до этого в нескольких вариантах: курсы, лекции, мастер-классы.

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

Раньше в курсах ведь что рассказывали: вот есть такие модели, вот так нужно составлять промпты, такие вот формулировки использовать... Но сейчас это всё уже ушло в прошлое. Если модель вас не понимает — возьмите нормальную топовую модель, перестаньте есть кактус. Не нужно уже растолковывать модели каждый шаг и расписывать роли. Всё это ушло в системные инструкции, rules.md и скиллы. И занимаются этим специальные люди — ну, впрочем, те, кто до этого экспериментировал с промптами. Хитрые промпты были нужны, когда модель вообще не понимала, чего от неё хотят. Сейчас такого у верхних моделей уже почти не встречается.

Сейчас горячие темы — управление контекстом, харнесс, гардрейлы, цепочки вызовов и проверок. Как кормить LLM контекстом и какие промежуточные артефакты она должна генерировать, чтобы и самой не запутаться, и человек мог быстро проверить, вот основные вопросы. Но ответов на них пока нет, потому что мы — сюрприз! — не до конца понимаем, что именно и как делает системный аналитик. В чем его основаная польза? Как проверить качество его работы? Где граница деятельности? Кто умеет на это отвечать, тот сможет построить ИИ-пайплайн, включающий задачи аналитика. Ну или будет пользоваться готовыми spec-kit или OpenSpec.

Вот только эти SDD-инструменты пришли с запада, а там, как мы знаем, организация разработки несколько отличается, и аналитиков уже давно нет. Ну и как работать с требованиями они, значит, тоже уже забыли. Программистам это всё тоже не нужно и не интересно, они приниципиально не понимают: "На первый взгляд может показаться, что эти требования и сценарии слишком очевидны. Но, во-первых, очевидные вещи тоже нужно где-то зафиксировать. Во-вторых, OpenSpec сгенерировал их самостоятельно — видимо, они ему всё-таки нужны." (это цитата из рандомной статьи программиста про SDD с Хабра). Требования, наверное, зачем-то нужны, ну пусть будут. Разработчика интересует, как всегда, другое — чтобы тесты были, чтобы стиль кода соблюдался, чтобы миграции нормально сформировались и применились.

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

История разделения труда дает нам двоякие примеры: с одной стороны, углубление разделения труда, с другой — наоборот, поглощение чисто навыковых профессий. Когда-то ретушер, линотипист и чертежник были отдельными профессиями, но цифра их съела. И все просто чертежники стали чертежниками-конструкторами. Кем станут аналитики, вот вопрос.

Знаете ли вы про добродетели хорошего программиста?

Лень, нетерпение и высокомерие.

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

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

Высокомерие (гордыня, самомнение) заставляет стремится к идеалу, чтобы никто не мог покритиковать решения, а только восхищаться ими.

Эти "добродетели" свойственны людям-программистам, но можно их привить и LLM-кодеру:

Ты — опытный инженер-программист, руководствующийся тремя добродетелями:

1. Ты ЛЕНИВ: Ты ненавидишь рутину и дублирование. Пиши переиспользуемый код (по приницпу DRY), автоматизируй всё, что можно, и создавай лаконичную архитектуру.
2. Ты НЕТЕРПЕЛИВ: Ты не терпишь медленный код. Оптимизируй алгоритмы (минимизируй Big O complexity), используй кэширование и асинхронность, чтобы система работала мгновенно.
3. Ты ГОРД: Ты пишешь код так, чтобы им гордиться перед сообществом. Он должен быть чистым, безопасным, задокументированным, снабженным тестами и устойчивым к любым ошибкам. Не выдавай "просто рабочий" код, выдавай шедевр.

Эти качества придумал Ларри Уолл, создатель языка Perl. Собственно, в языке это всё как раз и проявляется: можно очень быстро решить любую проблему коротким скриптом. Лень: не нужно придумывать имена переменным, часто их даже не нужно указывать. Прямо в язык встроены регулярные выражения.

There's More Than One Way To Do It, TMTOWTDI — можно одну и ту же вещь сделать совершенно разными способами, как удобно именно сейчас. Нетерпение: никакой компиляции, всё работает сразу из командной строки (помним, что это конец 80-х, и программы вообще-то компилировались, иногда десятками минут).

Гордыня: на Perl можно было писать программы, которые выглядели, как произведение искусства (абстрактное, постмодернистское). Говорили, что программы на Perl write-only, разобраться в них другой программист не может; говорили, что программа на Perl выглядит одинаково до и после обфускации.

В общем, язык для избранных. Или для хакеров в старинном смысле.

Но в массовом производстве Perl проиграл другим подходам, например — Python. В некотором смысле Python по философии противоположен Perl'у. Есть 'Дзен Python', набор принципов разработки:
1. Красивое лучше, чем уродливое
2. Явное лучше, чем неявное
3. Простое лучше, чем сложное
4. Сложное лучше, чем запутанное
5. Плоское лучше, чем вложенное
6. Разреженное лучше, чем плотное
7. Читаемость имеет значение
8. Особые случаи не настолько особые, чтобы нарушать правила
9. Хотя практичность побеждает чистоту
10. Ошибки никогда не должны замалчиваться
11. Если не отключены специально
12. Встретив двусмысленность, отбрось искушение угадать
13. Должен быть один — и, желательно, только один — очевидный способ сделать это
14. Хотя он поначалу может быть и не очевиден, если вы не голландец (отсылка к Гвидо ван Россуму).
15. Сейчас лучше, чем никогда
16. Хотя никогда зачастую лучше, чем прямо сейчас (нетерпение, помним?)
17. Если реализацию сложно объяснить — идея плохая
18. Если реализацию легко объяснить — идея, возможно, хорошая
19. Пространства имен — отличная штука! Давайте делать их больше!

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

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

Ты — ИИ-архитектор программного обеспечения, чей главный приоритет — чистота, читаемость и поддерживаемость кода. Ты строго следуешь философии "The Zen of Python":

1. ЯВНОСТЬ: Пиши код без "магии" и скрытых смыслов. Обязательно используй строгую типизацию (Type Hinting) и давай переменным говорящие, понятные имена.
2. ПРОСТОТА: Избегай оверинжиниринга. Выбирай самое простое решение из возможных. Держи структуру плоской, минимизируй вложенные циклы и условия.
3. ЧИТАЕМОСТЬ: Форматируй код идеально (по стандартам PEP 8 / Clean Code). Код должен читаться как хорошая проза.
4. ЧЕСТНОСТЬ С ОШИБКАМИ: Никогда не скрывай и не "приглушай" ошибки. Перехватывай только точечные исключения, пиши информативные логи, чтобы код не маскировал ошибки, а максимально их подсвечивал.
5. ПИШИ ДЛЯ ЧИТАТЕЛЯ: Рассчитывай, что твой код должен будет изучать, понимать и изменять кто-то другой. Помоги ему быстро во всем разобраться.

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

"Вся цифровая инфраструктура держится на библиотеке, которую в одиночку с 2003 года поддерживает рандомный чувак из Небраски"

А вы знаете, что эта картинка — ни разу не преувеличение? И вот тут ребята сделали классный сайт с неизвестными героями, на которых держатся все наши технологии: https://sheets.works/data-viz/holding-up-the-internet

Пол Эггерт, преподаватель из UCLA, с 2005 года поддерживает tz database — набор файлов с актуальным описанием часовых поясов во всех странах. На эту базу опираются все функции, связанные со временем — расписание поездов, билеты на самолеты, календари, включение фонарей по вечерам и всякое такое. Три миллиарда телефонов на Андроиде и миллиард на iOS, большинство серверов и почти все языки программирования.

Лассе Коллин в одиночку поддерживает xz — архиватор для всех серверов на Линуксе. Однажды он пустил к исходникам некоего китайца, немедленно встроившего в архиватор бэкдор, с тех пор не рискует.

Тодд Миллер, поддерживающий sudo. Неизвестный чел DRC, чья библиотека используется в каждом телефоне и браузере для открытия файлов jpg. Анонимная команда, разрабатывающая SQLite без внешнего финансирования, но с одним триллионом установок. zlib. bash. libxml2. curl. core-js.

Инфраструктура реально очень хрупкая. Bus-фактор многих проектов равен 1. Сделать с этим особо ничего нельзя, про это вообще никто не задумывается. sudo? curl? это же встроенные утилиты, разве нет? Разве их кто-то специально написал?

Я когда-то писал про бездумное использование общественных серверов точного времени (https://t.me/systemswing/528)

Мы привыкли, что инфраструктура... ну, просто есть. Как вода.

И это, кстати, интересный вопрос про видимость работы, в том числе и аналитика. Я когда-то в шутку предложил как критерий качества работы аналитика число восклицаний "О, об этом мы как-то не подумали!" в ответ на вопрос аналитика. Это шутка лишь отчасти. Я вижу — особенно в последнее время — много претензий к аналитикам, мол, а зачем вы нужны? Что вы делаете, какая от вас польза? Только задерживаете разработку. И многие аналитики даже не знают, что ответить на эту претензию (да даже и руководители анализа зачастую теряются).

Так нужно сделать видимой свою работу!

Как сертифицированный аудитор ISO 9000, говорю вам: записи первичны! Записи — всему голова! Что не записано, того и не было.

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

Так и для аналитика можно такие записи завести: EСR, Edge Case Record. Запись о выявленном граничном кейсе. Структура примерно такая: ID, дата, что нашли, предотвращенные последствия (что было бы, если бы не аналитик), принятое решение (тут можно дописать, сколько новых требований появилось и насколько это расширило скоуп; при желании можно даже выгоду посчитать — был ли выигрыш от исправления относительно риска потерь).

Соответственно, по этим записям для руководства считаем Shift-Left Index (Индекс раннего обнаружения): Количество критических логических ошибок и конфликтов интеграции, обнаруженных на этапе анализа, деленное на общее количество багов, найденных суммарно на всех стадиях разработки и в продакшене за тот же период. Ваш вклад — четверть или 70%? Можно ещё цену исправления прикинуть, в часах работы аналитика и остальной команды + простой.

Ну и заодно можно (и нужно!) считать снижение того самого bus-фактора (описали за квартал столько-то скрытых зависимостей и восстановили документацию к X легаси-компонентам и интеграциям).

И красивую инфографику со своими достижениями.

Я, кажется, нашел работающий вариант генерации диаграмм BPMN ИИшкой. И это, конечно, не просто промпт. Время промптов прошло, сейчас говорим про скиллы, харнесс и управление контентом.

Ну и это решение для BPMN — тоже скилл, причем там на входе промпты, а потом работа скриптов: промпт думает над процессом, оформляет его в виде промежуточного описания на JSON, JSON проверяется против схемы и против правил составления бизнес-процессов, потом загоняется в движок автолейаута и наконец сериализуется в BPMN 2.0 XML и отрисовывается в SVG.

Примерно такой пайплайн у меня и возник в голове, когда я несколько раз потерпел неудачу с генерацией промптом, но довести до ума не получилось. И то сказать — репозиторий этого скилла весит больше 5 Мб! В смысле, это исходные тексты, в основном .js, .md, .json и схемы. Не бывает таких промптов.

Точнее, промпты теперь размазаны по этапам выполнения скилла. Например, 42 правила формирования BPMN описаны в отдельном md-файле на 1028 строк, и таких файлов там пара десятков. То есть работает это как связка из промптов и скриптов на js, объединенных в пайплайн и обвешенных автоматическими проверками.

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

Вот, кстати, ссылки на него: https://github.com/Stieges/bpmn-generator, он есть и на MCP Market: https://mcpmarket.com/tools/skills/bpmn-generator

(И да, MCP-сервер там тоже встроен, качественный продукт).

Сделан он под Claude Code, но может устанавливаться и в другие AI IDE, я вот поставил себе в Курсор. Соответственно, если у вас используется VSCode с какой-то локальной моделью — можно и туда поставить.

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

Установка, если вы никогда со скиллами не сталкивались, относительно простая: сначала нужно куда-то склонировать репозиторий из Гитхаба, и запустить инсталляционный скрипт (а предварительно установить node.js и npm, конечно). Тут нужно немного побыть в шкуре программиста. Когда-то была шутка про "юзабилистов на питоне", ну вот мы теперь все — аналитики на питоне и js.

Когда всё установлено — просто создать папку скилла в вашем проекте (для Курсора это будет, например, .cursor/skills/bpmn-generator) и закинуть туда skill.md и ссылки на папки reference и scripts, IDE должен подхватить скилл автоматически.

И всё, начинаете пользоваться — вызывая явно по имени скилла, или он сам подхватится, если в запросе будут слова типа процессы, BPMN и т.д. Забавно, что запросы внутри скилла написаны частично на немецком, соответственно, и слова-триггеры тоже на английском и немецком. Если дойдут руки, попробую как-нибудь адаптировать к русскому весь это массив запросов.

В общем, кажется, сейчас курс по ИИ для аналитиков должен состоять из рассказа про VSCode/Cursor/Claude Code, какие скиллы в них установить и что написать в rules.md

В каждом проекте, где есть дизайнер и аналитик, есть главный вопрос: что должен делать дизайнер, а что аналитик? Кто за что отвечает?

Это, на самом деле, большая серая зона. С одной стороны, дизайнер отвечает за оформление, тут вопросов нет. Точнее, даже так: за структуру, компоновку и оформление. А аналитик отвечает за постановку задачи разработчикам, тут тоже никто не сомневается. А дальше начинается туман и неопределенность.

Например, дизайнер видит список, и на автомате рисует под ним пагинацию, а над ним блок фильтров и сортировку. И ещё строку поиска, ага. А у аналитика ничего такого не было, это новые требования! Чья это задача? Дизайнер выявил новые требования? Или аналитик не донес до дизайнера, что элементов в списке в 99,9% случаях не будет больше 7, и они поместятся на один экран?

Вообще, по моему опыту, дизайнеры довольно часто придумывают новые фичи. Иногда просто так :) У меня в одном проекте дизайнеры придумали кнопку "Случайный курс", типа как в классическом интерфейсе Гугла была кнопка "Мне повезет!". Зачем? Ну потому что в этом месте должен быть какой-то элемент, чисто для равновесия! Для них это просто кнопка, а поиск — просто строка. Для аналитика же поиск — это целый новый блок функциональности, возможно — целая новая подсистема со своими настройками, версиями, отдельным деплоем и встроенным ИИ. Или нет, нужно взять ещё неделю, чтобы разобраться, как этот поиск должен работать.

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

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

В общем, я для себя разработал чеклист, о чем нужно подумать, когда разрабатываешь дизайн, или передаешь задачу дизайнеру. Для каждого экрана:
1. Что это за экран, где я?
2. Что тут самое главное, что пользователь должен понять в первые секунды?
3. Какое главное действие должен сделать пользователь на этом экране?
4. Что ещё может сделать пользователь?
5. Какого типа этот экран? Он информирует, выводит список чего-то, что-то требует, предлагает что-то ввести или создать?
Обычно самые сложные формы, из которых выпадает больше всего новых требований — те, где выводится список и где нужно что-то создавать.

К ним отдельные требования: если у нас что-то выводится списком, то:
* как это показывать? (таблицей, списком, карточками, тайлами и т.п.)
* нужна ли пагинация?
* нужно ли это фильтровать? и по каким принципам?
* сортировать?
* нужно ли в этом списке что-то искать?
* нужно ли этот список выгружать в файл или куда-то передавать?
Соответственно, про фильтры и сортировку — нужно ли их сохранять, и как долго? То есть, есть ли у нас сущность "сохраненный поиск"/"настроенный фильтр", или нужно хотя бы сделать так, чтобы фильтр не сбрасывался при уходе и возврате на отфильтрованную страницу?

Отдельный частный случай списка — витрина. Там начинаются разные продуктовые штуки: что поднять повыше, как тасовать выдачу, чтобы было не скучно, как не обидеть разных поставщиков, если у вас их несколько, и т.п.

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

Какое актуальное мнение:

...для программистов наступают трудные времена. Объём и сложность программ возрастают, непропорционально по отношению к зарплате. Романтический ореол непостижимости этой профессии, если он когда-либо и существовал, начинает меркнуть. На Западе стартапы* тают как вчерашний снег, а программисты начинают пополнять армию безработных. Оспаривается даже само стремление рассматривать программистов как профессионалов особого рода. Главное же — это то, что вольная армия программистов постепенно попадает в «плен» к администраторам и руководителям, которые стремятся сделать труд программиста планируемым, измеряемым, однородным и обезличенным.

— Андрей Петрович Ершов, академик АН СССР, "О человеческом и эстетическом факторах в программировании", 1972 г.


* в оригинале — "софтверхаусы", которые Ершов определяет так:

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

Там же, кстати, про разделение проектирования и изготовления ПО и про конвейерный способ изготовления:

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

[..]

Руководители, ответственные за долговременные проекты, ищут пути к формализации этапов разработки и передаче проекта из одних рук в другие. [Но] само дело отчаянно сопротивляется такому разделению. По-видимому, правильное решение этого вопроса невозможно без учета человеческого фактора и эстетической потребности, препятствующей тому, чтобы заниматься реализацией чужих идей или не видеть самому овеществления своей идеи. Отдавать технический проект в другие руки — то же самое, что посылать своих детей в интернат.

** мы бы сейчас сказали — "выгорание"

Ну что, сейчас у нас есть возможность много меньшими усилиями самому овеществить свою идею. Дело за идеями.

Я закончил первую очередь небольшого проекта, который разрабатывал один при помощи ИИ. Не хочется говорить — вайбкодинга, потому что вайб — это, ну, сел, запилил быстро какую-то идею. Тут скорее речь про AI-SDLC: ну вот просто так сейчас устроена разработка, не людьми, а нейросетями.

Я в последний раз промышленно программировал в 2007, потом только разрабатывал технические задания, схемы автоматизации, архитектуру, дорожные карты и бэклоги. Один-два моих документа могли загрузить работой человек 40 на полгода-год. Сейчас мне показалось интересным вернуться и посмотреть, как все это делает ИИ.

И знаете, что? Офигенно!

Раньше я бы такой проект оценил минимум в полгода и минимум 3-4 разработчика (+тестировщик, +девопс). Мне хватает Курсора с подпиской Pro. При этом не нужно синхронизировать всех людей и их задачи. А ещё не нужно убеждать разработчиков сделать что-то, что выходит за рамки их привычного фреймворка. Например, у меня в проекте есть три кастомных компонента для полей формы, за каждый программисты мне попили бы крови: в фреймворке такого нет, это не стандарт, это будет плохо работать и т.п. ИИшка безотказная — надо, значит надо. А ещё её не напрягает и не пугает объем работы, она замечательно может протестировать этот компонент во всех вариантах и краевых случаях: когда мало элементов, когда много элементов, когда список пуст; на узких экранах, на мобилке, с выключенным JS и недогруженным CSS, с увеличенными/уменьшенными шрифтами, со скрин-ридером и контрастной чб-схемой и т.д. RTL мне не понадобился, и на том спасибо. В общем, обычно программисты такому резко сопротивляются.

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

Систему взял специально небольшую, чтобы я мог её сам держать под контролем:
6 ролей
6 внутренних модулей + очередь задач + внутренняя ИИ-модель
~45 сценариев
около 50 экранов
25 таблиц, примерно 15 справочников
Парочка огромных форм ввода на 30+ полей
7 интеграций: 3 внутренних и 4 внешних
Штук 6 объектов со своими состояниями + правила их переключения

В функциональных точках получается примерно 300-400, это довольно типовой размер проекта на 4-6 месяцев для небольшой веб-студии.

Что заметил за это время, пишу вперемешку про плюсы и минусы:

1. ИИ проще всего написать одну функцию / один законченный модуль. Вообще никаких проблем, всё пишет + тесты. Если хорошо поставлена задача. Как только какие-то места недостаточно конкретно прописаны, ИИ их либо срезает, либо наоборот — начинает вырастать лишнее, чего не нужно. Лишнее приходится обстригать, срезанное — доращивать. Это не очень напрягает, потому что происходит быстро. Дольше фиксировать в спеке.

2. С дизайном у меня не очень получилось. Говорят, Claude Design в этом хорош, у меня не было под рукой. Ну, то есть, какие-то общие подходы удалось найти, но иногда новый агент теряет и дизайн, и даже CSS-фреймворк, это нужно фиксировать и следить. В общем, понадобился дизайнер, чтобы придать некоторую консистентность внешнему виду.

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

4. Так же, как и человек (а может даже хуже), ИИ принимает некоторые решения без обсуждения и анализа. Иногда он попадает — когда мне лень ему подробно расписывать задачу. Иногда принимает решения, которые мне не подходят. Это не его проблема, он ведь не обладает всей полнотой информации. К счастью, почти все такие решения можно быстро откатить / переделать. Главное, вовремя о них узнать — тут стоит просить его показывать предположения, на которых он основывался, и решения, которые принял. Как найти подходящий уровень фиксации, я пока не понял: всю мелочь контролировать не хочется, по-верхам есть шанс что-то пропустить. Впрочем, это всплывает на тестах.

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

И вдогонку к предыдущему посту: конечно же, самые сложные места даже в простой системе — очередь задач и интеграции. (А очень часто очередь задач как раз и стоит перед интеграцией).

Ну, казалось бы: получил файл + описание, передал в LLM, получил результат (это так в этой системе).

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

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

Соответственно, на каждую из проблем есть лечение:
* перепосылки (на удаленной системе начинают задваиваться данные / дважды запускается расчет / наша система зацикливается в бесконечных перепосылках)
Лечение для лечения:
- уникальная идентификация запросов
- ограничение числа перепосылок

* Синхронизация схем данных с версионированием (реестр схем, обсуждение между системами готовности предоставлять данные в определенном формате определенной версии)

* Промежуточные сохранения и запуск процесса с середины (не запускать заново процесс расчета, если он ранее проведен и входные данные не изменились)

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

И это я ещё про гонки запросов не написал...

IT хоронят уже лет пятьдесят как минимум. Помните академика Ершова?

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

Похороны повторяются каждые 10-20 лет: новая технология, модный фреймворк, low-code, no-code, а теперь еще AI-агенты всех нас заменят. Но есть фундаментальные вещи, которые остаются необходимыми для успешного проектирования и разработки систем:

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

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

На этом и построен курс Андрея Буракова Интеграция и архитектура систем. Паттерны и технологии разбираем, конечно, но это не главное. Первично — научиться самостоятельно работать с незнакомыми задачи, анализировать контекст, выявлять ограничения и противоречия, видеть и решать архитектурные компромиссы, аргументировать свои решения. То есть ровно то, что не обесценится с выходом очередной модели.

Что внутри:
🔸 Сетевые протоколы и технологии интеграции
🔹 Производительность и надёжность: кеширование, балансировка, способы масштабирования
🔸 Инфраструктура: Docker, Kubernetes, Service Mesh
🔹 Выбор хранилища данных, репликация и шардирование
🔸 Консистентность, управление транзакциями, оркестрация и хореография

Андрей — аналитик, разработчик и техпродакт, работал в международных стартапах и кровавом энтерпрайзе, поэтому смотрит на архитектуру сразу с нескольких сторон.

🔗️️ Подробности и отзывы без цензуры смотрите на сайте, а сегодня еще действует ранняя цена.

Курс идёт по субботам с 14 ноября по 19 декабря

Реклама. ИП Бураков Андрей Олегович.
ИНН 632133429581