Від однієї юзер сторі до всього проєкту: фреймворк бізнес-аналітика на делівері-проектах із Claude

💡 Усі статті, обговорення, новини про AI — в одному місці. Приєднуйтесь до AI спільноти!

Я Володимир Кузняр, бізнес-аналітик у Geniusee. Останні місяці я перебудовую свою роботу на делівері-проекті навколо AI. У цій статті описую фреймворк, який я зібрав навколо роботи з Claude. Ідея підходу в тому, щоб AI працював на рівні не окремої юзер сторі чи епіку, а всього продукту. Для цього весь контекст проекту зібраний у файлах, з яких походять вимоги, а повторювані активності AI виконує через скіли.

Обмеження аутсорсу

У делівері-командах, з якими я працюю останній рік, AI використовують і в розробці, і в тестуванні. Код і тести реалізовуються швидше, тож BA теж долучаються використувати AI у роботі.

Ви й без мене знаєте, як це виглядає на рівні окремої сторі: закинув опис, отримав AC, закрив чат, і контекст зник разом із ним. Все, що AI знав про продукт, доводиться переносити руками в наступний чат, і чим далі йде проект, тим дорожче це перенесення.

Рішення про поведінку продукту, ролі користувачів і їхні права, домовленості з клієнтом живуть у голові BA, у нотатках, у розкиданих тікетах. AI щоразу бачить лише той шматок, який ви встигли йому показати.

Найпростіший вихід — віддати AI більше, ніж окрему сторі. Кілька моїх знайомих продакт-менеджерів у продуктових компаніях самі вайбкодять окремі фічі, закриваючи цикл end-to-end. Активності залишаються ті самі, змінюється тільки, хто їх виконує і скільки на них іде часу.

На аутсорсі так не вийде. Все, що буде в продукті, треба апрувати з клієнтом, а перед цим належно проелісітувати і провалідувати із стейкхолдерами. Ці обмеження фіксують набір активностей, які поки із процесу не викинути.

Змінити можна формат віддачі: замість сторі віддавати специфікацію, з якої розробка стартує напряму. Це підхід Spec-Driven Development. Але він вимагає зрілості з обох боків і поступового переходу.

Лишається одне: робити ті самі активності інакше. Що автономнішою стає реалізація, то більше роботи BA зміщується від виробництва окремих артефактів до роботи з контекстом як системою: спільна доменна модель, розділені факти, рішення і припущення, простежуваність. Далі — до специфікації, з якою агенти працюють напряму, без людини-посередника на кожному кроці. До цього повернусь у кінці статті.

Для кого ця стаття

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

У статті демонструю:

  • як влаштований контекст, що конкретно в ньому лежить і чому з нього походять усі вимоги
  • як виглядають скіли на конкретних BA-задачах: елісітація, моделювання, робота з дизайнами, оновлення тікетів в Jira та вимог у Confluence
  • що в цьому процесі вирішую я і в якій формі рішення приходять на апрув
  • місце фреймворку відносно Spec-Driven Development і агентних SDLC-фреймворків на кшталт BMAD, де роботу BA розкладено між агентами

Описане можна відтворити в себе, цілком або окремими активностями.

Глосарій

Далі в статті кілька термінів, які я вживаю в конкретному значенні.

Термін

Що це

Project Knowledge

Все, що AI має знати про проект, щоб працювати як я: продукт, делівері, стек, люди. Чотири текстові файли, які Claude бачить у кожному чаті проекту: Product Context, Project Context, Tech Context, Stakeholders

Product Context

Головний файл у Project Knowledge. У ньому лежить актуальний стан продукту: скоуп, ролі, права, глосарій, сутності, ухвалені рішення. Будь-яке питання «а що ми вирішили» йде туди. З нього походять усі вимоги.

System Prompt

Правила поведінки, які діють у кожному чаті: роль, мова відповідей, формати, коли зупинитись і спитати мене.

Скіл

Збережена інструкція на одну активність: як я її роблю, в якому форматі й з якими прикладами. Викликається з чату однією командою через «/».

MCP-конектор

З’єднання Claude із зовнішнім інструментом. Через нього він читає й пише в Jira, Confluence, Figma, не виходячи з чату.

Процес делівері і особливості фреймворку

Процес делівері, на якому я використовую фреймворк, йде епіками. Скоуп приходить після пресейлу у WBS, звідки й береться список епіків і юзер сторей хайлевельного рівня.

Для кожного епіку я елісітую вимоги із клієнтом, декомпозую їх на менші юзер сторі, описую критерії прийняття, валідую вимоги проти дизайнів, рефайню все з командою та готую до статусу готовності в девелопмент. Також я підтримую статус тікетів в репозиторіях (Jira та Confluence), опрацьовую запити на зміну та відповідаю на питання стейкхолдерів.

Думаю, у вас приблизно так само. Стаття написана за цією ж структурою активностей, тому її можна розглядати як холістично, так і автоматизацію окремих флоу.

Під ці активності й зібраний фреймворк: проект у Claude, файли контексту, скіли та MCP-конектори.

Архітектура фреймворку: інпути, механізм, контекст і аутпути. Product Context виділений окремо — це джерело, з якого походять усі артефакти. Діаграма у draw.io.

Як з’явився фреймворк

До фреймворку я дійшов почавши автоматизовувати окремі активності. Спершу це були кастомні GPT і Gemini із системними інструкціями під конкретні задачі: написати юзер сторі, описати API-протокол, згенерувати документ. Інструкція трималась у самому чаті, тож формат не треба було пояснювати щоразу заново — це й був перший крок від разових промптів до чогось повторюваного. Потім перейшов на Claude, бо він краще тримав формат артефактів і давав їх одразу придатними до роботи.

На одному з проектів я затестив актуалізацію всіх юзер сторі з Jira і валідацію їх на гепи проти дизайнів. Це була перша активність, де AI працював не з однією сторі, а з усім набором вимог одразу. Різниця виявилась не в швидкості, а в тому, що він побачив розходження, які я б шукав руками тиждень.

У паузі між проектами я зібрав ці активності в один процес та почав пілотувати фреймворк на новому делівері-проекті.

Далі описую, як ми погоджуємо роботу з даними, і як влаштований сам фреймворк. Якщо хочеться одразу до практики, конкретні активності описані в розділі «Основні активності BA із Claude AI».

Погодження з клієнтом і робота з даними

Використання AI на делівері це не рішення окремого BA. Воно узгоджується з клієнтом, і рамка узгодження визначає, з якими даними фреймворк працює.

Рамка фіксується по-різному. Використання AI і перелік субпроцесорів можуть бути прописані в контракті чи DPA. Там, де контракт не спускається до цього рівня деталізації, ми виносимо питання на кік-оф і закріплюємо рішення в BA approach, щоб домовленість була задокументована. Частина клієнтів має власні корпоративні підписки, тоді робота йде в їхньому периметрі й під їхніми політиками.

Окремо перевіряємо умови самого провайдера: що відбувається з даними після завантаження, чи йдуть вони на навчання моделей, які терміни зберігання. Це те, що клієнт має право знати до згоди.

Погоджена рамка не знімає з BA відповідальності за те, що він завантажує. Перед тим як віддати артефакт у чат, ми перевіряємо, чи не тягнеться разом із потрібним щось чутливе, чого робота не потребує, і прибираємо це. Це рутинна перевірка перед кожним завантаженням. З тієї ж причини всі скріншоти в статті зроблені на вигаданому тестовому продукті, внутрішній системі бронювання переговорок, а не на реальному проекті.

Архітектура і налаштування

Фреймворк розвертає ситуацію, з якої я почав. Стан продукту живе в одному місці постійно, актуалізується з кожною елісітацією, і вже з нього походять вимоги. Я не переношу контекст з чату в чат, весь проект має спільний контекст.

В цьому різниця з використанням AI як асистента на окремих задачах. Сторі, AC, флоучарт і прототип перестають бути незалежними інкрементами й більше не суперечать одне одному.

Механіка при цьому та сама, що й у звичайній роботі BA з AI: ті самі чати, ті самі промпти. Змінюється одне — AI відповідає за те, щоб контекст продукту лишався актуальним, і виконує активності на ньому.

BA делегує AI три активності:

Управління контекстом. AI відстежує, що змінилось після кожної елісітації чи коментаря клієнта, і повертає правки до Product Context, а я їх вношу.

Виконання активностей. Елісітація й моделювання: підготовка питань, флоучарти, декомпозиція, AC, валідації.

Підготовка рішень. AI не ухвалює рішень щодо продукту. Він доводить їх до стану, коли мені лишається прийняти або відхилити. Наскільки великий шматок він готує до апруву — це я задаю окремо.

Управління контекстом

Контекст живе в чотирьох текстових файлах. Поруч лежить WBS, щоб AI бачив первинну декомпозицію і скоуп. Разом вони складають Project Knowledge, який Claude бачить у кожному чаті проекту.

Project Knowledge: файли, які Claude бачить у кожному чаті проекту. Це тестовий проект, тому файли тут менші, ніж на реальному.

Головний із них product_context.md, він першим отримує інформацію про продукт. Під управлінням маю на увазі моніторинг змін і надання правок, самі оновлення вношу я.

Я вирішив зберігати в ньому все, що стосується продукту. Всередині одинадцять секцій:

  • скоуп і межі;
  • ролі й права;
  • стани користувачів;
  • доменна модель із сутностями та їхніми станами;
  • функціональні домени;
  • системні правила;
  • інтеграції;
  • аут оф скоуп;
  • глосарій;
  • мапа джерел;
  • матриця прав.

Кожне твердження має посилання на джерело: транскрипт із таймкодом, рядок WBS, документ від клієнта.

Розділення на секції працює чудово. Коли ми пишемо AC, ми звертаємось до конкретної секції, а не перечитуємо файл цілком. Або коли наприклад валідуємо дизайн, ми одразу звіряємо макет із потрібними нам ролями і станами. Також, коли рішення змінюється, я бачу, скільки секцій воно зачепило.

Фрагмент Product Context: кожне твердження має посилання на джерело — транскрипт із таймкодом або рядок WBS

З нього походять усі вимоги та артефакти. Дизайнер теж має відповідно актуальні права і пермішни ролей, стани сутностей при підготовці прототипів та мокапів. І навпроти цього ж документа я звіряю готовий макет.

Окремі вигоди файлу продуктового контексту

Файл доступний команді. Розробка та тестування можуть звіритись із поточними продуктовими рішеннями самостійно, не чекаючи, поки я відповім. Дизайн, вимоги, код і тести можуть звірятися з одним джерелом, тому розходження знаходяться між артефактами, а не в голові однієї людини.

Також кожен, хто користується файлом, його і перевіряє. Розробник може помітити розходження із кодом ще перед реалізацією.

На цьому ж можна поставити звірку коду з вимогами для BA: у Copilot чи Cursor є доступ до коду, а файл Product Context дає стан продукту цілком, а не поштучно по тікетах.

Флоу роботи із оновленням файлу такий: елісітація → аналіз елісітації із Claude → оновлення Product Context → підготовка вимог та артефактів → фідбек від стейкхолдерів → повтор кола.

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

Перевірку цей підхід не пройшов. Дизайнеру для перших мокапів знадобились ролі й права, і ми зробили Claude-артефакт Role & Permissions для валідації. На масштабі всієї системи він виявився нечитабельним, і ми його відкотили. Стало зрозуміло, що контексту потрібен живий файл, який оновлюється, а не артефакт, який щоразу генерується заново.

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

● ітерація 1 — WBS та Scope & Vision після дискавері
● ітерація 2 — кік-оф зустріч та список запитів до MVP
● ітерація 3 — елісітація #1 та окремий доменний документ
● ітерація 4 — елісітація #2

Щоразу я скидав пачку артефактів, Claude аналізував її і наповнював файл. Зараз ця робота загорнута в окремий скіл, тож на новому проекті контекст збирається з першого ж артефакту.

Рішення ухвалюється на одному епіку, а потрібне стає на іншому, і на той момент я вже не пам’ятаю, звідки воно взялось. Коли спливає питання «а що ми вирішили по пермішнах адміністратора на інтерфейсі бронювань?», відповідь шукається у файлі, а не в моїй пам’яті.

Якщо всі вимоги походять з одного файлу, є ризик, що помилка в ньому вплине на усі наступні артефакти та рішення. Тому файл постійно звіряється з реальністю:

  • кожну правку я проставляю вручну — читаю й вирішую по кожній зміні окремо, перш ніж вона стане частиною файлу;
  • дизайни валідуються проти контексту — і розходження так само часто означає, що застарів файл, а не макет;
  • декомпозиція епіка підсвічує флоу, які живуть у контексті, але не потрапили в жодну сторі;
  • готовий епік звіряється з контекстом окремим скілом — на суперечності, дублі й пропуски;
  • спірні місця перевіряю проти реальної системи: дивлюсь у код або питаю в девелопменту, як воно працює насправді.

Окремо я зберігаю Project Context: модель делівері та конвенції, які випливають із цієї моделі. Конвенція це правило, яке інакше довелось би проговорювати в кожному чаті. Наприклад:

  • питання клієнту: одне рішення на одне питання, без води, питання, що найбільше блокують, вгорі. Кожне питання починати з розуміння проблеми, а далі або її підтвердження, або уточнення, або незгода;
  • будь-яке припущення позначається як TBD і має відкрите питання, відповідь на яке його знімає;
  • імена стейкхолдерів з боку клієнта не потрапляють у клієнт-фейсинг артефакти — вимоги, чейнджлог, саммері.

Конвенції у Project Context: правила, які інакше довелось би проговорювати в кожному чаті.

Так калібрується формат аутпутів, поведінка в типових ситуаціях і межі, за які не виходимо.

У файлі tech_context.md я окремо зберігаю стек, інтеграції, архітектурні рішення, список сутностей. Завдяки йому все, що генерується, одразу елайниться з реальною системою. Claude знає, які сутності існують і як називаються, і не вигадує додаткових.

Tech Context: стек і зовнішні інтеграції, з якими звіряється все згенероване.

І також зберігаю файл stakeholders.md із RACI-матрицею. З нього Claude знає, хто за що відповідає і хто що вирішує. Тому відкриті питання одразу адресуються правильним людям, клієнту чи внутрішній команді, а не летять одним списком «комусь».

Stakeholders із RACI. Імена та контакти вигадані, як і сам продукт.

Збирати всі чотири одразу не треба. Product Context дає більшу частину користі сам, решта доростає з проектом.

Перетворення активностей на скіли

Для кожної повторюваної активності я сформував скіл. Раніше кожну активність я тримав окремим промптом і копіював його в новий чат щоразу, коли треба було щось зробити.

Скіл я збираю з активності, яка:

  • повторюється — декомпозицію я роблю для кожного епіка
  • має однаковий процес — послідовність кроків не залежить від епіку, з яким працюємо
  • має сталі правила — патерни поділу, формат сторі, що вважати вертикальним зрізом

Ще одним прикладом скіла є генерація чейнджлог-айтема. Замість щоразу пояснювати структуру айтема і що взагалі вважати зміною, вартою запису, я зібрав це в скіл і викликаю з чату.

Загалом, Claude скіл це md-файл, який містить структуровану інформацію: коли його викликати, що є інпутом, за якими правилами виконувати активність, у якому форматі віддати аутпут, і приклади аутпутів. Як я будую скіли, показую далі на прикладі декомпозиції епіка.

Активність викликається слешем прямо в чаті, посеред роботи. Не треба відкривати новий чат і переносити туди контекст.

Виклик скіла слешем: набираєш «/», вибираєш скіл.

Останній елемент архітектури це MCP-конектори. Вони дають Claude прямий доступ до зовнішніх систем. У мене підключені Jira і Confluence, Google Drive, Figma та FigJam, Miro, v0. Без конектора кожна операція з зовнішнім інструментом це експорт, копіпейст у чат і ручне перенесення результату назад. З конектором Claude читає й пише сам.

Прийняття рішень

Одне із завдань, яке доводиться вирішувати в процесі автоматизації активностей та роботи з продуктовим контекстом — налаштувати, який ступінь прийняття рішень можна віддати Claude і як цим рівнем керувати.

Це теж налаштування, і сам рівень знаходиться ітераціями та помилками.

Межі рішень задаються правилами в System Prompt. Разом із роллю BA, мовою відповідей і дефолтними форматами там лежать анти-галюцинаційні правила й конвенції поведінки. Окремі правила прописані в самих скілах.

В процесі використання фреймворку я інколи додаю додаткові правила та перевірки. Наприклад, побачив, що AI подавав власне припущення тим самим тоном, що й підтверджене клієнтом рішення. Додав в інструкції окреме правило: позначати такі твердження як припущення.

Також, щоб дати AI більше контексту для відображення мені потенційних рішень, окрім анти-галюцинаційних правил, ролі Claude, конвенцій, я пояснив Claude, чим ми з ним у цьому проекті загалом займаємось. В інструкціях це зафіксовано як Modes. Це опис активностей прямо в інструкціях проекту. Мод задає рамку на початку чату: що ми тут робимо, які скіли використовуємо, який результат маємо отримати. Ось як я це сформулював:

Project Instructions: опис циклу роботи над епіком, який Claude бачить у кожному чаті проекту.

І далі описав, як відбувається конкретна активність, наприклад нижче показав частинку аналізу вхідного артефакту:

Один із модів: мета, скіли які використовуються, та кроки обробки вхідних даних.

Ще один бенефіт — конструкція не привʼязана суто до Claude: System Prompt і файли контексту так само лягають у ChatGPT Projects чи Gemini Gems, а вміст скілів — як звичайні файли-інструкції, які використовувати там як промпти.

Зараз Claude готує рішення поштучно: декомпозицію на епік, AC на сторі, правки до контексту після зустрічі. Кожне я приймаю окремо. З накопиченням правил крок можна збільшувати, і наступний рівень це вже не одне рішення, а ланцюжок: проаналізував елісітацію, оновив вимоги, віддав саммері з посиланнями. Росте крок не тоді, коли модель стає кращою, а тоді, коли з’являється дешевий спосіб перевірити результат.

Модель теж впливає. На момент написання статті Opus я вмикаю для більшого міркування, Sonnet — на механічні речі. Opus дорожчий і повільніший, тому тримати його завжди сенсу немає.

Модель

Активності

Opus

Декомпозиція епіка, написання AC, звірка епіка з контекстом, валідація дизайну, аналіз елісітації та оновлення контексту

Sonnet

Саммері після зустрічі, чейнджлог, проектні документи з темплейта, швидкий пошук по контексту

Модель обирається в кожному чаті окремо, тому важка сесія з AC і швидкий чейнджлог можуть виконуватись на різних моделях.

Основні активності BA із Claude AI

Процес іде від елісітації до затверджених артефактів, і далі активності описані в тій послідовності, як вони відбуваються. Найбільше уваги тим, де цикл замикається на Product Context.

Активності BA по фазах. Мітки показують, що виконується скілом, а що лишається ручним. Діаграма у draw.io.

Елісітація

Підготовка

Оскільки джерелом всіх вимог є Product Context, з нього ж видно, яких вимог бракує і де є суперечності.

Для цього зробив окремий скіл, який читає поточний контекст і генерує структурований список питань по епіку, згрупований і відсортований за тим, що найсильніше блокує написання вимог. Питання одразу розмічені, кому вони адресовані — клієнту чи внутрішній команді.

Питання не беруться з загального чеклиста елісітації. Вони виводяться з самого файлу: там, де по темі є відкриті питання чи є суперечності. Тому список щоразу прицільний і прив’язаний до того, що вже вирішено, а не до того, що зазвичай питають на такому епіку.

Флоучарти

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

Скіл будує їх прямо у FigJam через нативний MCP-конектор Claude із Figma. Флоучарт горизонтальний, зі start- і end-івентами; блоки з відкритими питаннями підсвічуються червоним, додаткові коментарі жовтим. Зміст флоу береться з Product Context, тому червоне на схемі це те саме, що порожні місця у файлі.

Чернетка флоу від скіла: червоним — відкриті питання, жовтим — коментарі. Розкладку далі рівняю сам.

Далі залишається пройтись руками: повиносити блоки окремо від стрілок і візуально підрівняти. Ідеальної розкладки від скіла я так і не добився, FigJam погано налаштовується у розташуванні, тож фінальне вирівнювання ручне.

Інші діаграми та моделі

Мені поки окремі AI-тули для побудови діаграм та моделей заходять не дуже, тому малювати подобається самому: накидаю чернетку, а тоді звіряю її з Product Context. Це працює з будь-яким артефактом. Claude бачить, що вже вирішено по продукту, тому може і накидати варіант на наявних сутностях, і показати, де намальоване розходиться з контекстом. Інколи прошу згенерувати щось кастомне або віддати у форматі Mermaid, який розгортаю вже у draw.io. Також інколи використовую конектори з Miro чи з тим ж FigJam.

Прототипи

Для візуалізації ми також використовуємо прототипи. Весь продуктовий контекст уже зібраний, тож прототип успадковує ролі, стани й правила з нього. На демо клієнт бачить свої ж рішення, а не інтерпретацію інструмента. Окремо можна додавати UX-правила, щоб результат відповідав очікуванням. Інструментів прототипування достатньо: v0, Figma Make та подібні, і Claude працює з ними через конектор.

В описаних обмеженнях прототипування працює на елісітації краще за решту технік: перегляд прототипу скорочує кількість ітерацій фідбеку. Клієнт бачить рішення й реагує на нього, тому в дизайн іде вже звірена логіка.

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

Фідбек із демо прототипу йде тим самим шляхом, що й елісітація — у Product Context, а вже звідти у вимоги.

Аналіз елісітації

Сама зустріч проходить як завжди, тільки я майже не нотую — транскрипт фіксує все.

Після елісітації я додаю в чат Claude транскрипт зустрічі разом з артефактами, які обговорювали, і запускаю скіл аналізу елісітації. Транскрипт робимо інструментом, погодженим на проекті.

Claude аналізує транскрипт і виносить список поінтів — що і де треба оновити. Одна зустріч перетворюється на конкретні правки за кілька хвилин.

Для Product Context він дає правки у форматі find/replace: старий текст, новий текст. Я проставляю їх у файл через VS Code.

Правки до Product Context після елісітації: старий текст, новий текст — по одному айтему, з посиланням на секцію.

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

Для вимог та артефактів теж може бути одразу find/replace. Він віддає правки поайтемно, тож кожне рішення валідується окремо.

Моделювання

Декомпозиція епіка

У WBS скоуп лежить із хайлевел-декомпозицією. Частину сторі я дроблю на менші й деталізую, щоб кожна несла цінність і йшла в спринт незалежно.

Скіл для декомпозиції я будував так:

  • описав, що саме хочу зробити і яку проблему вирішую: щоб декомпозиція була повторюваною й не залежала від того, чи згадав я сьогодні всі патерни поділу;
  • взяв один реальний епік і поділив його сам, руками, як зробив би без AI;
  • показав результат Claude, і він зчитав, за яким патерном я ділив: workflow steps, CRUD, варіації бізнес-правил;
  • запакував цю логіку в скіл і відтворив.

Далі я прогнав скіл на кількох епіках і побачив слабке місце. Хоч би як добре він ділив, щось могло загубитись: флоу, який є в Product Context, але не потрапив у жодну сторі. Тому доклав окреме правило — підсвічувати потенційні пробіли.

На виході я отримував вертикальні сторі, згруповані під батьківськими WBS-сторі, з поясненням, яким патерном поділено і чому.

Декомпозиція епіка: дочірні сторі під батьківською WBS-сторі, з назвою патерну поділу.

Скіл робить механіку так, як робив би я, тільки швидше і не пропускаючи кроків.

Для візуалізації декомпозиції я також створюю user story map. Окремий скіл на основі проговореної декомпозиції розкладає батьківські WBS-сторі бекбоном, а дочірні — стовпчиками під кожною. Віддає у форматі xlsx, я вивантажую файл і імпортую в Miro чи FigJam, де рядки стають стікерами в потрібній розкладці.

На прикладі автоматизації цієї активності можемо детальніше поглянути, як я будую скіли.

Як робити скіли

Побудова скілів починається з проблеми, яку скіл вирішує.

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

Далі показую приклад того, як роблю це вручну, прошу фідбек, можу обговорити доцільність. Половина роботи тут не в скілі, а в тому, щоб самому сформулювати, що я роблю руками. Коли проблема сформульована, скіл із неї виводиться майже сам.

Решта скілів збирається так само. Я або описую Claude активність, або копіюю чат, де вже робив її з AI, і додаю приклади результатів (готові артефакти, вимоги, моделі), щоб було видно, як має виглядати аутпут. Далі прошу сформулювати скіл на основі того, що ми робили, і поставити питання, якщо чогось бракує. Claude збирає чернетку і доуточнює решту.

Приклад тут важливіший за опис. За описом виходить загальноприйнятий формат, за прикладом — той, який я можу одразу використовувати без правок.

Структура скіла в усіх однакова: коли викликати, що є інпутом, за якими правилами виконувати, у якому форматі віддати, приклади. Тому готовий скіл далі працює як шаблон для наступного: даю його як зразок і прошу зібрати такий самий під іншу активність.

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

Скіли зручно тримати бібліотекою: один раз зібрав, далі викликаєш будь-коли. Ними можна ділитись із командою бізнес-аналізу, тоді формат вимог не залежить від того, хто саме їх писав.

Написання AC

Після декомпозиції для отриманого списку юзер сторі я починаю описувати AC. На більшості проектів роблю це технікою EARS, трохи кастомізованою окремими правилами: щоб опис був простий і читабельний.

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

Єдиним джерелом вимог для скіла є Product Context. Коли щодо сторі лишаються відкриті питання, скіл виносить їх окремим блоком вниз сторі.

Це скіл, який я рефайнив найчастіше. Багато правок було мінорних: коли поля форми краще винести таблицею в Data Dictionary, а коли вистачить булет-списку. Також зіткнувся з проблемою: коли запускаю скіл одразу на кілька сторі, Claude застосовує його частково, навіть при прямій вказівці. Краще по одній.

AC у форматі EARS із Data Dictionary; TBD стоять там, де рішення ще нема.

Валідація AC

Зробив скіл для валідації тих самих сторі. Задав йому критерії:

Повнота: happy path, альтернативні флоу, edge cases, error states;

Якість: атомарність, тестованість, однозначність.

Скіл повертає список правок, а не переписані сторі. В одному чаті я кілька разів поспіль прогнав валідацію після правок сторі. Далі Claude почав викликати її сам: переписав сторі й одразу прогнав через валідацію, без моєї команди. Патерн роботи із критеріями прийняття він зчитав із того, як я працював у цьому ж чаті.

Тікет менеджмент та репозиторії

На проектах для тікет-менеджменту та бази знань проекту у нас використовуються Jira та Confluence. Claude підтримує конектори з хмарною Jira, а для self-hosted використовується окремий MCP-сервер.

Через нього Claude читає поточний опис тікета, звіряє його з Product Context і пише туди фінальні вимоги.

Для операцій запису поставив собі в System Prompt окреме правило: перед записом чогось через конектор — показати план і попросити мій апрув.

Валідація дизайнів

Також автоматизував валідацію дизайнів. У Figma експортую потрібні фрейми в PDF, скидаю Claude і запускаю скіл валідації: він звіряє відмальовані інтерфейси з Product Context та вимогами.

Я попросив віддавати структуру, яку можна швидко відсканувати: де співпадіння, де неточності, де Product Context мовчить. Якщо в контексті рішення немає, це не помилка дизайнера, а відкрите питання, і скіл не має вигадувати зауваження на порожньому місці. Розходження теж читаю у два боки: або застарів макет, або застарів файл.

Звіт валідації: співпадіння, розходження, і окремо те, про що Product Context мовчить.

Механічне порівняння забирає скіл. У кінці за запитом він видає готові коменти по кожному фрейму, які я додаю у Figma.

Окремі активності

Проектні артефакти

Один із перших юзкейсів, за який мені сподобався Claude. На старті проекту я готую низку BA-документів: BA approach, комунікаційний план, підхід до управління вимогами, стейкхолдер-мапу з RACI. Темплейти в нас зберігаються в BA-вікі, тому скіл будується просто: даєш темплейт, Claude запаковує в нього те, що вже знає про проект.

Контекст на цей момент уже зібраний: цілі, скоуп, обмеження, ролі й зони відповідальності. Тому в BA approach активності одразу розкладені по фазах проекту, а в комунікаційному плані стоять реальні ролі, а не плейсхолдери.

Темплейт при цьому лишається один на всі проекти: змінюється контекст, а не скіл. На новому проекті той самий скіл генерує документи заново, вже з його даними.

Якщо хочеться спробувати фреймворк на чомусь малому, починати найзручніше саме звідси. Темплейти у BA зазвичай уже є, скіл збирається за одну сесію, а перший документ виходить у той самий день.

Чейнджлог

Підготував окремий скіл для генерації айтема в чейнджлог. Зміни в скоупі ми ведемо в таблиці формату WBS, з окремими колонками під причину, суть зміни, статус.

Скіл корисний тим, що зміну треба спершу впізнати. На дзвінку вона звучить як одна фраза серед решти обговорення, а Claude все одно підсвічує її при аналізі зустрічі й питає, чи писати айтем.

Я підтверджую, що це справді зміна, варта запису, і він збирає айтем: нова вимога, зміна наявної чи прибране зі скоупу — кожен тип заповнюється по-своєму. Далі копіпейстом закидаю в таблицю.

Покращення процесу

Коли бачу проблему з якоюсь активністю, одразу питаю Claude, що не враховано в процесі чи скілі, і з цим фідбеком перезаписую скіл.

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

Аналіз власного процесу: активність, проблема, що впровадив. Таблиця у draw.io.

Той самий класичний геп-аналіз, просто навколо AI-процесів.

Робота з чатом

За час роботи з AI, періодично рефлексуючи над процесом, назбиралось трохи принципів, які використовую в роботі.

Вирівнювання контексту перед початком завдання. Маю кілька патернів:

  • (A) після опису проблеми прошу чат поставити мені до 10 уточнювальних питань — так ми калібруємо і себе (нічого не пропустили), і впевнені, що AI забере всі потрібні дані для завдання;
  • (Б) можу попросити підсумувати, як AI зрозумів задачу, — підтверджую чи поправляю, і тоді починаємо;
  • (В) описати, що не підходить в аутпуті, — це теж формує контекст наступних ранів («не той пріоритет питань»; «йдемо з X, Y відкидаємо — надто детально»). Так AI тримає це в контексті й не повертається до відкинутого.

Окремий чат під активність. На Opus довгий чат тримається добре, я можу вести цілий епік в одному. Але кожна ітерація тягне за собою всю історію, тож довгий чат коштує дорожче. Тому велику задачу розділяю на послідовність: аутпут кроку 1 стає входом кроку 2, кожен крок ревʼюабельний, помилку видно одразу. Якщо не встигаю завершити, прошу AI дати опенінг-промпт, щоб почати новий чат із потрібного контексту.

Product Context на моєму проекті важить 434 кБ і займає 7% ємності проекту в Claude. Тобто в стелю впертися важко, і ділити файл доводиться не через розмір, а щоб бачити історію змін.

Кілька чатів паралельно. Деколи відкриваю собі одразу кілька чатів і працюю по різних епіках: поки в одному Claude відповідає, в іншому ставлю наступне питання. Це помітно скорочує час роботи.

Approach-first для великих задач. Перш ніж починати складну або ризиковану задачу, прошу згенерувати план. Так помилку в підході видно до того, як за ним щось зроблено, і AI вже знає, по якому плану рухатись.

Результати

Час

На початку пілотного проекту домовились із компетенс-лідом трекати, наскільки фреймворк економить час BA. Міряємо не проект цілком, а час на окремий епік.

Точні цифри залишаються у внутрішньому бізнес-кейсі, але картина по завершених епіках стабільна. Економія є на більшості з них, найбільша там, де контекст простіший: менше сторі й менше відкритих питань.

Налаштування займає час на старті: скіли, System Prompt, структура файлів контексту. Далі воно працює саме по собі. На новому проекті скіли й System Prompt я переношу без змін, а заново заповнюю тільки файли контексту.

Якість

Час не єдине, що змінилось. Якість ми не трекаємо, тому далі мої спостереження, а не заміри.

Повнота. AI звіряє кожну сторі з усім контекстом, тому едж-кейси підтягуються з правил продукту, і на брейнштормінг та пошук сценаріїв йде менше часу. На декомпозиції це видно найкраще: скіл підсвічує флоу, який є в Product Context, але не потрапив у жодну сторі. Плюс накидає варіанти рішень там, де я б обмежився основним флоу.

Пам’ять. Коли розробник запитає, що стається з даними користувача після деактивації — я опрацьовую запитання через чат, і Claude шукає відповідь у контексті. Не треба пригадувати самому й перекопувати нотатки.

Однорідність. Claude тримає формати: ті самі патерни поділу, та сама структура AC, ті самі правила для питань клієнту. Він сам нагадує, коли я від них відхиляюсь.

Простежуваність. За кожним твердженням у контексті стоїть джерело: транскрипт із таймкодом чи рядок WBS. Тому видно не тільки що вирішили, а й де саме.

Швидкість зворотного зв’язку. На елісітацію я приходжу з повнішими питаннями, тому ітерацій менше. А те, що прозвучало на зустрічі, доходить до вимог того самого дня.

Наступні кроки

Фреймворк має своє місце в загальній автоматизації делівері з AI. Мій колега Євген Клюкін розібрав модель Дена Шапіро з шести рівнів автоматизації розробки і те, що на кожному стається з роллю BA. Два з них описують, на якому рівні стоїть описаний фреймворк зараз.

Рівень 2 — це перехід від разових запитів до повторюваних скілів, робочих процесів і проектних інструкцій.

Рівень 3 — робота з контекстом як із системою: спільна семантика, розділені факти й припущення, простежуваність, автоматичні перевірки узгодженості.

Фреймворк закриває рівень 2 і частково заходить на третій. Product Context уже тримає посилання на джерела, розділяє підтверджене й запропоноване, звіряється окремим скілом. Але живе одним файлом.

Якщо дивитись на цей процес далі, я бачу чотири окремі напрямки покращення: активності, контекст, автономію і формат віддачі.

Активності. Закриті скілами, це те, що описано вище в статті.

Контекст. Один файл замінити на дерево: репозиторій під git, файл на епік, ID на кожній вимозі. Тоді видно історію рішень, а не тільки поточний стан, і зміну можна відкотити.

Напрямок, у який я для цього дивлюсь, це LLM-вікі: база пов’язаних markdown-нотаток, яку наповнює AI. Сутності, ролі, рішення й епіки стають окремими нотатками з посиланнями одна на одну. Тоді при зміні AI проходить не весь файл, а тільки зв’язки, які вона зачепила. Переглядати таку базу зручно в Obsidian: він працює зі звичайною папкою markdown-файлів і показує зв’язки між нотатками графом.

Автономія. Зараз human in the loop організований так:

  • правки до Product Context приходять у форматі find/replace, і кожну я вношу сам;
  • перед записом у Jira чи Confluence Claude показує план і чекає мого апруву;
  • скіли валідації повертають список правок, а не переписаний артефакт.

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

Формат віддачі. Це домовленість із розробкою, і сам BA її не змінює. Spec-Driven Development стартує зі специфікації як із даності, а зібрати її і є вся робота до цього. Але готується вона в контексті: ID на кожну вимогу й нумеровані AC це передумова такої віддачі. Тому вкладення в контекст окупається, навіть якщо до зміни формату не дійде.

Коли я дивлюсь на агентні SDLC-фреймворки на кшталт BMAD, то бачу там багато тих самих активностей, які описав вище. Робота, яку я описав у статті, там розкладена між агентами: один збирає бриф, другий пише PRD, третій нарізає сторі для розробника. Кожен передає артефакт наступному.

Скіли роблять те саме без агентів: роль, інпут, формат аутпуту. Плюс правила, за якими AI ухвалює рішення і коли зупиняється спитати мене. Артефакти передаються через Product Context, а не від агента до агента. Керую цим всім я — кожен скіл викликаю сам.

Рух далі впирається в модель аутсорсу. Елісітація й апрув проходять через людей на боці клієнта, а ці кроки з процесу не викинути. Тому питання не «чи лишається BA», а хто перевіряє згенероване і хто відповідає за рішення. Людина залишається рівно там, де рішення.

Що можна робити з цим практично

На новому проекті і на тому, що вже йде, старт виглядає по-різному.

Новий проект. Контекст росте разом із проектом: перший артефакт після дискавері вже йде в Product Context, і кожне твердження одразу має джерело. Далі як описано вище: елісітація, оновлення контексту, декомпозиція, AC, Jira.

Проект, який вже триває. Спочатку зібрати те, що є: специфікації, тікети, WBS, транскрипти. Виходить поточний стан продукту. Історії рішень у ньому не буде, зате він підтверджений тим, що вже працює. Джерела додаються далі, з кожною наступною елісітацією.

Брати фреймворк цілком не обов’язково, активності можна забирати по одній. Все потрібне для цього описано вище: з чого складається Product Context, як із активності збирається скіл, які правила лежать у System Prompt.

Висновки

Фреймворк це, по суті, мій власний процес роботи як BA, записаний у файли. AI виконує його, але спершу довелось сформулювати, що саме я роблю і за якими правилами.

Для мене одна з ключових змін у тому, що змінюється сам предмет роботи: замість окремої вимоги ми більше працюємо з тим, що її виробляє: контекст, правила в скілах, перевірки. Сама вимога стає результатом налаштування.

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

Робота зі стейкхолдерами теж залишається. AI готує питання точніше й швидше, але поставити їх і домовитись про відповідь доводиться на зустрічі. Те саме з апрувом: сайн офф вимог та дизайнів за стейкхолдерами.

Сам підхід можна розвивати далі. Контекст, скіли й межі автономії допрацьовуються окремо, і кожна проблема в роботі стає наступною правкою.

Ми поступово віддаємо AI своє розуміння роботи — не задачу, а спосіб, у який вона робиться. Якщо Claude чи будь-який інший AI завтра перестане працювати, сподіваюсь, що я все ж працюватиму так само, просто вручну.

👍ПодобаєтьсяСподобалось17
До обраногоВ обраному10
LinkedIn
Дозволені теги: blockquote, a, pre, code, ul, ol, li, b, i, del.
Ctrl + Enter
Дозволені теги: blockquote, a, pre, code, ul, ol, li, b, i, del.
Ctrl + Enter

Маю такий апдейт до статті: Після недавньго релізу Claude тепер dміє сам редагувати файли в Project Knowledge, тож переносити правки в Product Context через VS Code більше не треба.

Порядок майже той самий. Після елісітації Claude дає список правок до Product Context, я переглядаю кожну й апрувлю. Далі він сам вносить їх у файл у Project Knowledge і перевіряє, що все лягло.

Human in the loop досі є, але так пропускаємо тепер ручний крок із копіюванням. Лиш застереження, шо у Project Knowledge немає історії змін і кнопки «скасувати». Тому версію Product Context тримаю окремо, комітом у репо або збереженою копією.

Між публікацією статті й цим апдейтом минуло три тижні) Виходить, частина того, що я описував як процес, виявилась обходом обмежень інструмента. Тому важливо при побудові таких сетапів, не надто прив’язуватись до інструментів. Хоч це і була позитивна зміна)

Привіт! дякую за статтю на доу про фреймворк з автоматизації аі менеджменту контексту! я багато корисного підчерпнув для себе, хоча я інженер

привіт! дякую вам за відгук. радий, що корисно)

Володимире, дякую за статтю, дуже цікаво!
Я зараз якраз дійшла до того, що треба збирати «Product context» для дуже старого і дуже великого проєкту, тому ваша стаття трапилась дуже вчасно.
Маю кілька питань, буду вдячна за відповіді.

1. Скажіть, будь, ласка, яка деталізація тверджень в вашому Product Context? Це високорівневий опис фічей (stakeholder reqs), чи це аналог FR/NFR, чи деталі вимог, наприклад, рішення по інтерфейсу (отут буде тултіп, а не попап) теж загорнуті в нього?

2. Як оновлення Product Context сінхронізується з розробкою? З того, що я прочитала, я зрозуміла, що файл оновлюється після апруву (але до розробки). Відповідно він завжди йде на крок попереду фактичного коду? Ймовірно, вимоги що вже заапрувлені, але не імплементовані якось позначені в файлі? Якщо так, то хто і в який момент відповідає за оновлення позначки? І як ви відпрацьовуєте наступні ситуації:
— якщо фактична розробка має розходження з твердженнями в файлі?
— Якщо в останній момент відкотили зміни? (кансельнули тікет посеред спринту, наприклад)

3. Чи при аналізі нових вимог ви перевіряєте їх виключно о Product Context, чи, також, о реальний код продукту?

Якщо вам є ще щось додати цікавого, про що я не додумалась спитати, не соромтесь, буду вам дуже вдячна :)

Дякую! Радий, що стаття трапилась вчасно)

1. Деталізація. Product Context тримає рішення про поведінку продукту: бізнес-правила, ролі й права, стани сутностей, флоу, інтеграції, обмеження. Це рівень, близький до FR/NFR та вимог стейкхолдерів.

Інтерфейсні деталі на кшталт «тултіп, а не попап» туди не потрапляють, вони живуть в дизайнах та критеріях прийняття. Сторі і критерії прийняття виводяться з PC, а не навпаки.
Винятком може бути, коли UI-рішення змінює поведінку, наприклад «підтвердження перед видаленням сутності обов’язкове». Тоді воно стає правилом і йде в контекст.

Кожне твердження у файлі контексту має посилання на джерело (транскрипт, айтем Change Log, коментар клієнта)
..............................................................................

2. Синхронізація з розробкою. Product Context описує погоджений стан продукту, а не імплементований, тому він іде на крок попереду коду. Окремої позначки «заапрувлено, але не реалізовано» у файлі в мене зараз немає. Статус реалізації живе в Jira, а контекст відповідає на питання, як продукт має працювати.

— Якщо розробка розійшлась із контекстом, спершу з’ясовуємо, хто правий. Якщо помилка в коді, це баг. Якщо розробники знайшли кращий варіант чи технічне обмеження, це зміна.

— Якщо зміну відкотили, наприклад тікет кансельнули посеред спринту, це теж зміна скоупу.

Це якраз одна з причин, чому наступним кроком я хочу перенести контекст під git і додати статус кожній вимозі. Тоді стан «погоджено / в роботі / реалізовано» стане видно в самому контексті.
..............................................................................

3. Перевірка нових вимог. Зараз нові вимоги я звіряю з Product Context і дизайнами. З кодом звіряються розробники, коли беруть сторі в роботу, і вони теж дають фідбек, якщо бачать розходження. Звірку з кодом з боку BA я планував робити, але не через Copilot чи Cursor, робитиму це через Claude Code.
..............................................................................

Що додати для старого великого проєкту: Замість одного файлу, я б одразу дивився в бік варіанту, який порадили в коментарях вище: база markdown-нотаток під git, наприклад в Obsidian. Кожна сутність, вимога чи рішення лежить окремою нотаткою з ID, статусом і посиланнями на пов’язані нотатки. Тоді при зміні AI проходить тільки зачеплені зв’язки, а не весь контекст, і видно історію рішень. Сам я зараз поступово вже переходжу на таке ж. Підключив Obsidian, поставив Claude Code у VS Code.

«not bad» ©

Напрямок, у який я для цього дивлюсь, це LLM-вікі: база пов’язаних markdown-нотаток, яку наповнює AI. Сутності, ролі, рішення й епіки стають окремими нотатками з посиланнями одна на одну. Тоді при зміні AI проходить не весь файл, а тільки зв’язки, які вона зачепила. Переглядати таку базу зручно в Obsidian: він працює зі звичайною папкою markdown-файлів і показує зв’язки між нотатками графом.

Тут так само немає проблем, робив таке. По суті, треба мати гарний структурований (як правило, ієрархічний) індекс-каталог документів. Також підтримку переходів між документами, MD + github + Obsidian локально чудово це розуміє. І крос-посилання на технічний архітектурний індекс (кодова база) — тому що архітектура вимог != технічна архітектура.
Ну і декілька правил/інструкцій для claude.md як цим керувати.

дякую, шо поділились!
насправді, однією із мотивацій публікації статті — було бажання отримати фідбек та зрозуміти, а як у інших наразі цей сетап побудовано)
тож радий, шо бачення та напрям сходиться. дякую за деталі і повернусь із результатом

Чудова робота, продуманий сетап, пізнавальна стаття!👍

дякую дуже за відгук, фідбеки та можливість!

Володимире, дякую за статтю та ноледж шерінг.

Я пішов якраз у напрямку, який ви описуєте як наступний крок. Контекст у мене живе не в одному файлі, а в LLM вікі на Obsidian під git: п’ять продуктових стрімів, понад тисяча нотаток. Сутності, вимоги з ID, ADR, сорси, мітинги, etc. — окремими нотатками з frontmatter (статус, версія, changed_from, change_reason) і зв’язками depends_on. Правила вікі прописані в CLAUDE.md, тож модель знає, куди і як писати. Це дало історію рішень і відкат через git, аналіз впливу змін по зв’язках, а не по всьому файлу, і кілька стрімів в одній базі. А продакт контекст стає не якимсь рукописним файлом, а зрізом, який можна згенерувати з графа.

Через MCP підключені Jira + Conflu (для селф-хостед довелося написати свій сервер), транскрипти зустрічей (Fellow), робочі чати (Telegram MCP + Slack), беклог-таблиця через Gdrive і GitLab (який теж селф-хостед і за ВПН), і т.д. 11 різних scheduled tasks щодня заносять нове у вікі, тож я не переношу транскрипти руками.

На деяких з них звісно ж етап human-in-the-loop, але коли AI пише у вікі сам, суперечності накопичуються: за три місяці в мене зібралося близько 40 contradictions. Вони були коректно позначені, а не перезаписані, але ніхто їх не закривав. Але це звісно ж вирішується скедюлд таском по збору та резолву таких айтемів. Іноді при великій кількості контесту та задач (а з часом кількість логіки в продукті чи кількох продуктів зростає) можна забувати «логати» інформацію у вікі, тож я б дозував і балансував якось human-in-the-loop тільки для дійсно важливих рішень по вимогам.

У вас же я точно заберу дві речі: посилання на джерело на рівні кожного твердження (у мене воно на рівні сторінки) і замір часу на епік — бо без цього складно довести ефект комусь, крім себе).

Якщо будете мігрувати з одного файлу, я б почав так: розбити секції Product Context на окремі нотатки з ID (BR-, FR-, NFR-, т.д.), додати статус і версію у frontmatter, поставити все під git і завести явні позначки якихось суперечностей. Апрув на рівні вимог залишити за людиною звісно ж, а автоматизувати спершу саме інджест контексту через MCP (будь то офіційні чи власні локальні сервери), scheduled tasks, etc.

дуже вдячний за такий розгорнутий фідбек і ваш ноледж шерінг))

гарно розгорнули сетап. якраз хочу на такий перейти) переконали, що дивлюсь у правильному напрямку!

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

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

відносно дозування human in the loop погоджуюсь. з часом, як контекст накопичується, все важче звіряти кожен едж кейс, тож планую додати якісь правила закриття едж-едж кейсів в користь можливих найпростіших рішень та проходу по них батчем пізніше

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

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

Дуже цікаво і корисно, дякую!