Или что происходит, когда AI-агенты сами ведут спринт-борд

Дисклеймер: оригинал статьи написан автором для medium.com на английском языке. Для адаптации на русский язык использовалась помощь AI.

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

Ни один тикет не обновлен. Таймер не запущен. Чат на тысячу строк, но он испарится, как только закроешь сессию. А когда коллега спросит, что было сделано за день, ты будешь восстанавливать картину по памяти. Удачи.

Меня это достало. Заканчиваю марафон-сессию с Claude или Codex, ощущение, что гора работы сделана, а доска проекта все так же показывает Not Started. Тайм-трекинг? Какой тайм-трекинг. Разрыв между реальной работой и тем, как выглядит проект, стал просто нелепым.

Сон, который все изменил

Однажды я просидел часов пять без перерыва. Фичи, баги, прыжки между терминалом, IDE и доской Mattermost, где жили мои задачи. Я был убит.

И лег поспать.

Просыпаюсь, пялюсь в потолок, голова еще не включилась, и тут доходит: почему я посредник? Зачем я вручную открываю борд, ищу задачу, обновляю статус, запускаю таймер, потом возвращаюсь в терминал и объясняю агенту, что делать? Почему агент не может делать это сам?

Все кусочки были на месте. У Mattermost Boards полноценный REST API. AI-агенты типа Claude Code поддерживают MCP-тулзы. Нужно было просто соединить одно с другим.

В тот же вечер я начал писать Skate.

Что такое Skate?

Skate – это CLI-тулза и MCP-сервер на Go, который дает AI-агентам прямой доступ к вашим Mattermost Boards. Агент может листать задачи, выбирать по приоритету, менять статус, запускать таймер (пояснение ниже), работать, оставлять комменты и закрывать задачу. Без единого alt-tab в браузер.

Почему Skate? В английском to skate through something значит пролететь через что-то быстро и без усилий. Собственно, это и происходит. Задачи, на которые у меня уходили часы – покопаться в коде, написать фикс, обновить доки, протестировать – закрываются за минуты, когда у Claude есть борд с задачами. Говоришь “next task” и смотришь, как оно едет. Skate through your backlog. Буквально.

Вот как это выглядит:

$ skate tasks
ID                           TITLE                        STATUS       PRIORITY   ASSIGNEE
c4cf6f4wzbjgxdm3hpa7iygtjdo  Task translation middleware  Not Started  2. Medium
cuppcm819atnixx71qg9i485jsr  listing tasks                In Progress  1. High 🔥

Говоришь Claude: take the next task by priority. Он запускает skate tasks, берет задачу с наивысшим приоритетом, читает описание через skate task <ID>, обновляет статус, стартует таймер, делает работу, оставляет коммент с описанием изменений, останавливает таймер и закрывает задачу.

Полный цикл. Без рук.

Какую проблему я на самом деле решал

Если вы работали с AI-агентами для кода – Claude Code, Cursor, Codex, чем угодно – вы наверняка упирались в ту же стену. Эти штуки невероятно мощные в написании кода. Но они абсолютно не в курсе вашего проджект-менеджмента. Не знают, над чем вы должны работать. Не обновляют тикеты. Не трекают время.

А контекст? Я на этом одно время помешался. Даже написал тулзу Pantry специально для того, чтобы агенты могли сохранять заметки между сессиями. Решения, паттерны, баги – все хранится локально в SQLite с семантическим поиском. Работало неплохо.

Но вот в чем дело: у Claude теперь контекстное окно на миллион токенов. Память агента больше не является узким местом. Узкое место – это память человека. Когда три разных агента работали над проектом в разных сессиях, тебе надо понимать, что происходило. Нужны таймстемпы, комментарии, борд, который отражает реальность.

Для этого и нужен Skate. Не память агента – а память команды.

Как это работает

Skate – это один статический бинарник на Go. Никаких баз данных, демонов, Docker-контейнеров. Просто HTTP-запросы к Mattermost API с Bearer-токеном.

Настройка занимает секунд 30:

skate init          # Вводишь URL Mattermost и токен
skate local-init    # Выбираешь, какой борд использует этот проект
skate setup claude-code  # Регистрируешь MCP-сервер

Все. Claude Code получает девять тулзов: листинг бордов, листинг задач, просмотр деталей, обновление статуса, создание задач, комментарии, старт/стоп таймера и ручной ввод времени.

Под капотом все примитивно. Skate шлет HTTP-запросы на ваш Mattermost с Bearer-токеном. Boards-плагин рулит пермишенами – если вы видите борд в браузере, Skate видит его из терминала.

Форматы вывода гибкие. По умолчанию чистая таблица для людей, но можно гнать --json или --yaml для скриптов:

skate tasks --json | jq '.[] | select(.Priority | test("High"))'

Перевод на лету

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

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

Поэтому я добавил middleware для перевода. Опционально, включается в конфиге через любой OpenAI-совместимый API (OpenAI, Ollama, OpenRouter, что угодно). Когда Skate рендерит задачу, он прогоняет быструю эвристику: текст в основном ASCII? Пропускаем. Нет? Переводим. Агент видит чистый английский. Оригинал на борде не трогается.

# ~/.config/skate.yaml
translate:
  enabled: true
  provider: ollama
  model: gpt-oss:latest
  base_url: http://localhost:11434/v1

Звучит тривиально, но реально помогает, когда команда разбросана по разным странам.

Как я создавал это с помощью AI

Тут начинается мета-часть. Я создавал Skate тем самым воркфлоу, который Skate и обеспечивает. Как только базовый CLI заработал, я начал использовать его для управления собственной разработкой. Создал задачи на борде Mattermost, настроил Skate и сказал Claude: take the next task by priority.

И оно заработало. Claude:

1. Запускал skate tasks чтобы увидеть задачи

2. Брал задачу с наивысшим приоритетом

3. Читал полное описание через skate task <ID>

4. Ставил статус In Progress

5. Запускал таймер

6. Делал работу (код, фиксы, доки)

7. Оставлял коммент с описанием того, что сделано

8. Останавливал таймер

9. Ставил Completed

10. Спрашивал: next task?

Более 30 задач были закрыты таким образом. Каждая – с таймстемпами, комментариями и трекингом времени. Когда я потом посмотрел на борд, было видно, что именно произошло, в каком порядке и сколько времени заняло.

В этом весь смысл. Не просто сделать работу – а знать, что было сделано.

Повторяющиеся задачи: перетащил, бросил, снова готово

Один паттерн, который возник сам собой – повторяющиеся задачи. Обновить README, прогнать тесты, проверить доки – это не разовые вещи. Каждый раз, когда добавляешь фичу или фиксишь баг, README может потребовать правки, тесты нужно обновить, доки могут устареть.

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

Это на удивление мощная штука. У меня задача Update README была закрыта и переоткрыта раз шесть за время разработки. Каждый раз агент читает свои же прошлые комменты, видит, что было добавлено в прошлый раз, и дописывает новое. Ноль повторных инструкций с моей стороны. Просто двигаешь карточку и говоришь next task.

То же самое с тестами. Add/update tests – задача, которая возвращается снова и снова. Агент проверяет текущее покрытие, видит, какой новый код появился, пишет недостающие тесты, прикладывает вывод. Мне не надо объяснять, что изменилось – он сам это выясняет, глядя на код.

Когда агент становится частью команды

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

Со Skate просто говоришь: создай задачу. Агент выполняет skate create, заполняет заголовок и описание прямо из текущего разговора, и задача появляется на борде. Без браузера, без переключения. Мысль летит из головы прямо на доску за секунды.

Но дальше – интереснее. Для крупных задач агент не бросается сразу писать код. Он сначала исследует кодовую базу, продумывает подход, оформляет план в виде markdown-файла и прикладывает его к тикету. Потом ставит статус Blocked и ждет. И вот о чём я изначально и не думал: другие члены команды видят этот план на борде. Могут прочитать, оставить комменты, поспорить с решениями, предложить альтернативы. Агент подхватывает фидбэк, обновляет план, прикладывает новую версию и начинает писать код только после того, как подход одобрен.

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

Это полностью меняет динамику. Агент больше не спрятан внутри чьей-то IDE. Его работа видна: план приложен, статус отслеживается, время залогировано, комменты документируют каждое решение. Любой в команде может увидеть, над чем агент работает, сколько это заняло времени и почему были приняты те или иные решения. Когда кто-то присоединится к проекту через полгода и спросит “почему это сделано именно так?” – ответ будет в тикете.

Скилл-файл: один документ, который всем управляет

Все это – обновление статусов, трекинг времени, меншены, планы, контент-блоки – управляется одним markdown-файлом под названием SKILL.md. Он встроен в бинарник Skate и устанавливается вместе с MCP-сервером при запуске skate setup. Агент читает его один раз и следует ему всю сессию.

И вот что меня по-настоящему удивило: агент следует этим инструкциям лучше, чем любой человек.

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

Агент не забывает. Он читает скилл-файл и делает ровно то, что там написано. Каждый. Раз. Обновляет статус перед началом работы. Запускает таймер. Проверяет приложенные файлы. Меншенит последнего комментатора. Пишет итог. Останавливает таймер с заметками. Прикладывает план. Не потому что он мотивирован или дисциплинирован – а потому что он буквально выполняет полученные инструкции. Без эго, без срезания углов, без “сделаю потом”.

Одно из требований скилл-файла – подписи. Каждый коммент и заметка к таймеру заканчиваются строкой вроде -- claude-code (claude-opus-4-6) или -- codex (gpt-5-codex). Звучит как мелочь, пока не начинаешь работать с несколькими агентами на одном борде. У меня Claude Code разбирал задачи на одном проекте, пока Codex параллельно работал на другом. Когда потом смотришь на борд, каждый коммент подписан – сразу видно, какой агент что сделал, с какой моделью и в каком порядке. Без гадания, без “кто это написал?”

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

Скилл-файл – это примерно 130 строк markdown. Никакого кода, никакого парсинга конфигов, никакой интеграции через API – просто понятные инструкции на человеческом языке. И они превращают AI-модель общего назначения в предсказуемого, надежного тиммейта, который берет на себя всю операционку, с которой люди справляются отвратительно.

Хотите, чтобы агент вел себя иначе? Отредактируйте скилл-файл. Хотите отключить меншены? Добавьте mentions: false в конфиг. Хотите, чтобы он всегда прикладывал планы? Это уже там. Весь воркфлоу – декларативный, версионируемый и прозрачный.

Технические детали (для тех, кому интересно)

• Язык: Go. Один бинарник, без CGO, кросс-компиляция на Linux/macOS/Windows одной командой.

• MCP-транспорт: stdio. Агенты запускают Skate по требованию, нулевые затраты в idle.

• Конфиг: YAML с трехуровневым мерджингом (глобальный → локальный для проекта → env-переменные).

• Зависимости: Cobra для CLI, официальный OpenAI Go SDK для перевода, MCP Go SDK для интеграции с агентами.

• Кеширование: User ID резолвятся в юзернеймы и кешируются в ~/.cache/skate/users.yaml.

• Версия: задается при сборке через ldflags, общая для CLI, HTTP User-Agent и MCP-сервера.

Весь проект – около 2000 строк на Go. Делает одну вещь и делает ее хорошо.

Про плагин Boards

Стоит оговориться: у меня не стоковый Focalboard. Я поддерживаю кастомный форк плагина Boards, в который добавил несколько вещей, которых в оригинале никогда не было. Самое важное – тайм-трекинг. Возможность стартовать и останавливать таймеры в задачах и логировать часы – это именно то, что делает цикл автоматического трекинга агентом возможным. Есть и другие мелочи, нужные под наш воркфлоу, которые не тянули на upstream PR, но в повседневной работе заметно помогают.

Skate работает с API этого плагина. Если у вас ванильный Focalboard, все остальное работает как положено – списки задач, статусы, комменты, аттачи. Просто эндпоинтов для тайм-трекинга не будет. Skate это обрабатывает нормально: если API таймеров нет, он скажет об этом и пойдет дальше. Без крашей, без сломанных воркфлоу.

Дальше Mattermost: Jira, Linear и все остальное

Вот о чем я постоянно думаю: в этом подходе нет ничего специфичного для Mattermost Boards.

Я не единственный, кто заметил разрыв между AI-агентами и проджект-менеджментом. Такие проекты, как Vibe Kanban (Rust, 13k+ звезд) и Kanban Code (Swift), решают ту же задачу. Выглядят впечатляюще – Vibe Kanban дает параллельную оркестрацию агентов с изолированными git worktree, визуальные код-ревью, все дела. Kanban Code автоматически связывает сессии Claude с карточками и двигает их по борду по мере мерджа PR.

Но есть нюанс: все они создают новый канбан-борд. Новый UI, новый воркфлоу, новый инструмент, который всей команде нужно освоить. Если команда уже сидит на Jira, или Mattermost, или Linear – теперь у вас два борда. AI-борд и настоящий борд. И удачи уговорить PM-а проверять AI-борд.

Skate идет от противного. Он не заменяет ваш борд – он к нему подключается. Команда продолжает пользоваться тем же бордом Mattermost, теми же колонками, тем же воркфлоу, тем же мобильным приложением. Агент просто появляется как еще один участник. Никакой миграции, никакого обучения, никакого “ребят, давайте все перейдем на новый инструмент”. Борд остается на месте. Агент приходит туда, где команда уже работает.

Паттерн универсальный. Есть AI-агент. Есть система управления проектами с API. Нужен тонкий stateless мост между ними – что-то, что говорит на MCP с одной стороны и на REST с другой. Это и есть Skate. Сегодня он работает с Mattermost Boards. Но та же архитектура – тот же набор команд, тот же MCP-интерфейс, тот же паттерн со скилл-файлами – может работать с чем угодно.

Jira? Легко. Linear? Еще проще, у них отличный API. GitHub Projects? Shortcut? Notion? У всех одни и те же базовые объекты: задачи, статусы, комменты, ответственные. Глаголы идентичны: list, create, update, comment, track time.

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

Skate – мой proof of concept для его закрытия. Mattermost Boards был стартовой точкой, потому что я им пользуюсь. Но идея больше любого конкретного инструмента. Если у вас Jira и вы хотите, чтобы ваш Cursor-агент разбирал тикеты, обновлял статусы и логировал время – блюпринт уже здесь. Форкните, замените API-клиент, оставьте MCP-тулзы. Сложность не в HTTP-вызовах, а в проектировании воркфлоу так, чтобы агент понимал, как быть хорошим тиммейтом. Это задача скилл-файла, и эта часть полностью портабельна.

Для кого это

Если вы используете Mattermost Boards (или standalone Focalboard) и работаете с AI-агентами, Skate убирает разрыв между бордом и терминалом. Ваши агенты становятся полноценными членами команды, которые сами обновляют свои тикеты и трекают время.

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

Если вы соло-разработчик и хотите просто сказать Claude – возьми следующую задачу – и чтобы он понимал, что это значит, Skate и есть этот мост.

А если вы вообще на другой PM-системе – читайте код, заимствуйте паттерн. Будущее AI-разработки – это не просто более умные агенты. Это агенты, которые участвуют в тех же процессах, что и люди, с той же ответственностью и тем же аудит-трейлом.

Попробовать

git clone https://github.com/mobydeck/skate
cd skate
make install
skate init

Open source, один бинарник, бесплатно. Самое сложное – это вовремя лечь поспать.

Skate – open source, github.com/mobydeck/skate. Написан на Go, работает на кофеине и посленаповом озарении.