Get Shit Done: полный HandBook по методологии GSD для Claude Code — Василий Рассказов

Зачем тебе это читать

GSD — это система разработки, которая превращает Claude Code из «умного автокомплита» в полноценную инженерную команду. Не метафора. Буквально: 11 типов субагентов, wave-based параллелизм, goal-backward верификация, автоматический code review, threat-модели по STRIDE, Nyquist-валидация тестового покрытия. И всё это управляется десятком slash-команд.

Проблема, которую GSD решает, простая: Claude Code без системы — это гениальный стажёр. Он напишет что угодно, но забудет проверить, не сломал ли соседний модуль. Сделает фичу, но пропустит edge case. Исправит баг, но создаст два новых.

GSD — это тот самый слой дисциплины между «напиши мне фичу» и production-ready кодом. Система, которая заставляет AI сначала подумать, потом спланировать, потом сделать, потом проверить. Причём на каждом шаге — отдельный субагент с чистым контекстным окном, чтобы не было галлюцинаций от перегруза.

Я разобрал всю методологию и собрал три режима работы: от «сделай за 2 минуты» до «я строю продакшен и хочу спать спокойно». Плюс отдельные секции про добавление фич в готовый проект и про фиксы багов.

Как устроен GSD изнутри

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

Оркестратор — это твой основной Claude Code. Он никогда не делает тяжёлую работу сам. Его задача: понять, что нужно, вызвать нужного субагента, дождаться результата, решить что дальше. Контекстное окно оркестратора остаётся на 30–40% даже после часов работы — это принципиально.

Субагенты — специализированные AI, которых оркестратор спавнит под конкретные задачи:

gsd-planner — архитектор, пишет планы
gsd-executor — разраб, реализует планы
gsd-phase-researcher — исследователь, копает документацию и подходы
gsd-verifier — верификатор, проверяет что цель фазы достигнута
gsd-plan-checker — валидирует план по 6 измерениям до начала работы
gsd-code-reviewer — никогда не угадаете 🙃
gsd-security-auditor — проверяет threat model
gsd-debugger — systematic debugging с persistent state
gsd-nyquist-auditor — генерит тесты для покрытия requirements
gsd-codebase-mapper — анализирует существующую кодовую базу
gsd-ui-researcher — генерит UI-спецификации

Каждый субагент работает в изолированном git worktree с чистым контекстом. Это значит, что executor не «помнит» мусор из фазы планирования, а verifier смотрит на результат свежими глазами.

Wave-based параллелизм: планы внутри фазы группируются в волны по зависимостям. Все планы в одной волне выполняются параллельно. Это основной механизм скорости.

Goal-backward верификация: проверка идёт от цели фазы, а не от списка задач. Закрыть все задачи и не достичь цели — это fail. GSD проверяет observable behaviors, а не галочки.

Структура проекта

GSD создаёт директорию .planning/ в корне проекта. Вот что там живёт:

.planning/
├── PROJECT.md              # Видение, контекст, ограничения
├── REQUIREMENTS.md         # Requirements с REQ-ID, v1/v2/out-of-scope
├── ROADMAP.md              # Фазы, критерии успеха, зависимости
├── STATE.md                # Текущее состояние, решения, блокеры
├── config.json             # Настройки workflow
├── phases/
│   └── XX-phase-name/
│       ├── XX-CONTEXT.md   # Решения из discuss-phase
│       ├── XX-RESEARCH.md  # Результаты исследования
│       ├── XX-YY-PLAN.md   # Атомарные планы задач
│       └── VERIFICATION.md # Результат верификации
├── research/               # Domain research
├── reports/                # Отчёты сессий
├── todos/                  # Идеи и задачи
├── debug/                  # Debug-сессии
├── intel/                  # Codebase intelligence
└── codebase/               # Brownfield mapping

Режим 1: Speed Run (быстрый)

Когда времени мало, задача понятна, а идеальное качество не критично. MVP, прототипы, хакатоны, pet-проекты.

Инициализация

/gsd-new-project --auto

Флаг --auto означает: не задавай лишних вопросов, используй разумные defaults. GSD всё равно соберёт requirements и roadmap, но не будет мучить тебя уточняющими вопросами.

Если у тебя уже есть PRD или описание проекта в файле:

/gsd-new-project --auto @idea.md

Настройки для скорости

/gsd-settings

Выставляй:

model_profile: budget (Sonnet для кода, Haiku для research и верификации)
granularity: coarse (3–5 фаз вместо 8–12)
workflow.research: false (пропускаем research перед планированием)
workflow.plan_check: false (пропускаем верификацию планов)
workflow.nyquist_validation: false (пропускаем генерацию тестов)
workflow.skip_discuss: true (пропускаем discuss-phase)

Цикл разработки

/gsd-plan-phase 1 --auto
/gsd-execute-phase 1
/gsd-next                    # автоматически определит следующий шаг

/gsd-next — твой лучший друг в speed run. Не думай, какую команду запускать — система сама разберётся.

Для совсем мелких вещей:

/gsd-fast "добавь кнопку logout в хедер"

/gsd-fast — это inline-исполнение без субагентов. Максимум 3 файла. Для тривиальных правок.

Для задач побольше, но без полного церемониала:

/gsd-quick "добавь авторизацию через OAuth"

/gsd-quick — субагент-executor, atomic commits, но без discuss-phase и verification loop.

Полная цепочка Speed Run

/gsd-new-project --auto
/gsd-settings  # budget, coarse, отключить research/plan_check/nyquist
/gsd-plan-phase 1 --auto
/gsd-execute-phase 1
/gsd-plan-phase 2 --auto
/gsd-execute-phase 2
...
/gsd-complete-milestone

Или вообще на полном автопилоте:

/gsd-new-project --auto
/gsd-settings                # настроить
/gsd-autonomous              # запустить всё без вмешательства

/gsd-autonomous пройдёт discuss → plan → execute для каждой фазы самостоятельно. Остановится только на явных checkpoint’ах или ошибках.

Режим 2: Balanced (оптимальный)

Стандартный режим для нормальной разработки. Research включён, планы проверяются, верификация работает. Но без паранойи.

Инициализация

/gsd-new-project

Без --auto — система задаёт вопросы, пока полностью не поймёт цели, ограничения, технический стек, edge cases. Внутри запускается 4 параллельных research-агента для исследования домена.

На выходе: PROJECT.md, REQUIREMENTS.md, ROADMAP.md, STATE.md.

Если проект brownfield (уже есть код):

/gsd-map-codebase            # 4 параллельных агента анализируют код
/gsd-new-project             # вопросы адаптируются под то, что уже есть

Настройки

/gsd-settings

model_profile: balanced (Opus для планирования, Sonnet для исполнения)
granularity: standard (5–8 фаз)
Все workflow toggles: defaults (research on, plan_check on, verifier on)

Цикл фазы

/gsd-discuss-phase 1         # интервью: серые зоны, решения → CONTEXT.md
/gsd-plan-phase 1            # research → plan → verify план
/gsd-execute-phase 1         # wave-based execution → auto-verify
/gsd-verify-work 1           # UAT если нужно

Discuss-phase — принципиальный шаг. Система сама определяет тип фазы и задаёт вопросы: для UI-фичи спросит про layout и empty states, для API — про формат ответа и обработку ошибок, для data pipeline — про формат данных и retry-логику. Все решения фиксируются в CONTEXT.md, и планировщик их читает.

Если не хочешь отвечать на вопросы, но хочешь контроль:

/gsd-discuss-phase 1 --assumptions

В assumptions-режиме система сама анализирует кодовую базу, выкатывает свои предположения с уровнями уверенности (Confident / Likely / Unclear), а ты только корректируешь то, что неправильно.

Цепочки

/gsd-discuss-phase 1 --chain  # discuss → автоматически plan → execute

Флаг --chain — для тех, кто доверяет системе. Обсудили, сразу планируем, сразу делаем. Без пауз.

Полная цепочка Balanced

/gsd-map-codebase            # если brownfield
/gsd-new-project
/gsd-settings                # balanced defaults
# Для каждой фазы:
/gsd-discuss-phase N
/gsd-plan-phase N
/gsd-execute-phase N
/gsd-verify-work N           # при необходимости
# Финализация:
/gsd-audit-milestone
/gsd-complete-milestone

Режим 3: Paranoid (максимальное качество)

Production-grade код. Всё включено, все проверки пройдены, все агенты отработали. Код, за который не стыдно на code review.

Инициализация

/gsd-map-codebase            # обязательно для brownfield
/gsd-new-project             # полное интервью + research

Настройки

/gsd-settings

model_profile: quality (Opus для всех decision-making агентов, Sonnet для верификации)
granularity: fine (8–12 фаз, мелкая нарезка)
workflow.research: true
workflow.plan_check: true
workflow.verifier: true
workflow.nyquist_validation: true
workflow.ui_phase: true (для фронтенда)
workflow.ui_safety_gate: true
git.branching_strategy: phase (отдельная ветка на каждую фазу)

Цикл фазы: каждый шаг обязателен

# 1. Обсуждение
/gsd-discuss-phase N --analyze     # с trade-off analysis для каждого решения

# 2. UI-спецификация (для фронтенд-фаз)
/gsd-ui-phase N                    # UI-SPEC.md с дизайн-контрактом

# 3. Планирование
/gsd-plan-phase N --reviews        # research → plan → verify → cross-AI review

# 4. Исполнение
/gsd-execute-phase N               # wave-based + auto-verify

# 5. Ручное UAT
/gsd-verify-work N                 # conversational UAT с auto-diagnosis

# 6. Валидация тестов
/gsd-validate-phase N              # Nyquist: есть ли тесты на каждый requirement?

# 7. Security
/gsd-secure-phase N                # STRIDE threat model verification

# 8. Code review
/gsd-code-review N                 # must-fix / should-fix / nice-to-have
/gsd-code-review-fix N --auto      # auto-fix до 3 итераций

# 9. Cross-AI review
/gsd-review N                      # peer review от других AI (Gemini, Codex, etc.)

# 10. UI-аудит (для фронтенда)
/gsd-ui-review N                   # 6-pillar visual audit, score 0-24

# 11. Ship
/gsd-ship N                        # PR с полным описанием из артефактов

Что даёт каждый шаг

discuss-phase —analyze — не просто собирает решения, а анализирует trade-off для каждого. «Выбрали PostgreSQL вместо MongoDB: вот что теряем, вот что получаем».

ui-phase — спавнит gsd-ui-researcher, который создаёт UI-SPEC.md: spacing system, typography, color tokens, copywriting tone. Потом gsd-ui-checker валидирует спецификацию. Если BLOCKED — ревизия до 2 итераций.

plan-phase —reviews — после создания планов запускает cross-AI review. Другой AI (Gemini, Codex) смотрит на план свежими глазами.

validate-phase — Nyquist-аудитор проверяет: для каждого requirement из PLAN.md <must_haves> существует ли тест? Если нет — генерит. Создаёт VALIDATION.md с Test Infrastructure table и Per-Task Map.

secure-phase — читает threat model из PLAN.md (STRIDE-register), проверяет каждую угрозу: CLOSED (митигация есть в коде) или OPEN (нет). Блокирует продвижение если threats_open > 0.

code-review — три severity tier’а: must-fix (блокирует PR), should-fix (warning), nice-to-have. С --auto фиксер автоматически чинит и перезапускает review до 3 раз.

ui-review — 6 pillar’ов: copywriting, visuals, color, typography, spacing, experience. Каждый от 0 до 4, максимум 24. Может использовать Playwright для скриншотов.

Полная цепочка Paranoid

/gsd-map-codebase
/gsd-new-project
/gsd-settings                      # quality, fine, всё включено

# Каждая фаза:
/gsd-discuss-phase N --analyze
/gsd-ui-phase N                    # если фронтенд
/gsd-plan-phase N --reviews
/gsd-execute-phase N
/gsd-verify-work N
/gsd-validate-phase N
/gsd-secure-phase N
/gsd-code-review N
/gsd-code-review-fix N --auto
/gsd-review N
/gsd-ui-review N                   # если фронтенд
/gsd-ship N

# Финализация:
/gsd-audit-milestone
/gsd-plan-milestone-gaps           # если audit нашёл дыры
/gsd-docs-update                   # генерация документации с верификацией
/gsd-complete-milestone

Сравнительная таблица режимов

Шаг	Speed Run	Balanced	Paranoid
Map codebase	—	по ситуации	обязательно
New project	`--auto`	полное интервью	полное интервью
Model profile	budget	balanced	quality
Granularity	coarse (3–5)	standard (5–8)	fine (8–12)
Discuss phase	skip	обязательно	`--analyze`
UI phase	—	по ситуации	обязательно
Research	off	on	on
Plan check	off	on	on + `--reviews`
Execute	wave-based	wave-based	wave-based
Auto-verify	—	on	on
Manual UAT	—	по ситуации	обязательно
Nyquist validation	off	off	on
Security audit	—	—	обязательно
Code review	—	по ситуации	обязательно + auto-fix
Cross-AI review	—	—	обязательно
UI audit	—	—	обязательно
Docs generation	—	—	обязательно
Git branching	none	none	per-phase

Добавление фич после основной разработки

Ты завершил milestone, всё работает, прошло время. Теперь нужно добавить новую функциональность. Три пути в зависимости от размера.

Мелкие фичи (1–3 файла)

/gsd-fast "добавь dark mode toggle в настройки"

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

Средние фичи (нужен план, но не целая фаза)

/gsd-quick --full "добавь экспорт в CSV для таблицы пользователей"

Quick-mode с флагом --full включает: lightweight discuss → research → plan-check → execution → verification. Трекается отдельно в .planning/quick/, не засоряет основной roadmap.

Флаги --full можно разбирать по частям:

--discuss — только обсуждение серых зон
--research — только research
--validate — только plan-check + post-execution verification
--full — всё вместе

Большие фичи (новая фаза или milestone)

Вариант A: добавить фазу в текущий milestone

/gsd-add-phase                     # добавляет в конец
# или
/gsd-insert-phase 5.1 "OAuth"     # вставляет между 5 и 6 (decimal numbering)

Потом стандартный цикл:

/gsd-discuss-phase 5.1
/gsd-plan-phase 5.1
/gsd-execute-phase 5.1

Вариант B: новый milestone

/gsd-new-milestone "v2.0 — Enterprise features"

Система загрузит контекст предыдущего milestone, запустит research, соберёт новые requirements, создаст roadmap. Seeds (идеи, которые ты сохранял через /gsd-plant-seed) автоматически всплывут как кандидаты.

Backlog-управление

Идеи, которые «когда-нибудь потом»:

/gsd-add-backlog "WebSocket support для real-time обновлений"
/gsd-plant-seed "Миграция на edge runtime когда Vercel стабилизирует API"

Когда придёт время:

/gsd-review-backlog              # просмотреть, промоутить в milestone или удалить

Seeds отличаются от backlog тем, что у них есть trigger_when — условия, при которых идея становится актуальной. Система сама подсветит seed при создании нового milestone, если условия совпали.

Параллельная разработка фич

Если нужно пилить несколько фич параллельно:

/gsd-workstreams create "auth-overhaul"
/gsd-workstreams create "dashboard-v2"

/gsd-workstreams switch "auth-overhaul"
# работаешь над auth...

/gsd-workstreams switch "dashboard-v2"
# работаешь над dashboard...

/gsd-workstreams complete "auth-overhaul"

Workstreams — это namespaced контексты. Каждый трекает свой прогресс, не мешая другим.

Починка багов: debug flow

GSD подходит к дебагу системно. Не «поменяй строчку и посмотри что будет», а «найди root cause, зафиксируй, проверь что фикс работает».

Простой баг (знаешь где проблема)

/gsd-fast "исправь off-by-one в pagination, файл src/utils/paginate.ts:42"

Мелкий фикс, известное место — не нужен никакой церемониал.

Баг средней тяжести (знаешь симптом, но не причину)

/gsd-debug "пользователи жалуются что фильтры сбрасываются после навигации назад"

/gsd-debug — это полноценная debug-сессия с persistent state. Спавнит gsd-debugger, который:

Формулирует гипотезы
Собирает evidence
Сужает scope
Предлагает фикс с обоснованием

Debug-сессия сохраняется в .planning/debug/. Если контекст сбросился — можно продолжить с того же места. После успешного фикса сессия переезжает в .planning/debug/resolved/.

Баг после верификации фазы

Если верификатор нашёл проблемы (gaps в VERIFICATION.md):

/gsd-diagnose-issues             # root cause analysis для каждого gap
/gsd-plan-phase N --gaps         # создать планы для фиксов
/gsd-execute-phase N --gaps-only # выполнить только фиксы
/gsd-verify-work N               # перепроверить

Это автоматический цикл. --gaps флаг говорит планировщику: не планируй заново всю фазу, только закрой дыры из VERIFICATION.md.

Баг найден code review

/gsd-code-review N               # найти проблемы
/gsd-code-review-fix N --auto    # автофикс с итерациями (до 3 раундов)

Фиксер читает REVIEW.md, чинит must-fix issues, запускает review заново. Повторяет пока не чисто или пока не кончится бюджет итераций.

Регрессия (что-то сломалось после обновления)

/gsd-undo --last 5              # показать последние 5 GSD-коммитов

/gsd-undo использует git revert --no-commit, никогда git reset. История не переписывается. Можно откатить целую фазу:

/gsd-undo --phase 3             # откатить все коммиты фазы 3

Или конкретный план:

/gsd-undo --plan 3-2            # откатить только план 3-2

После отката — перепланировать и переделать:

/gsd-plan-phase 3
/gsd-execute-phase 3

Workflow сломался (GSD сам запутался)

/gsd-forensics "execute-phase зависла на wave 2"

Post-mortem. Анализирует git history, артефакты планирования, целостность state. Ставит диагноз: stuck loop, missing artifacts, abandoned work, crash, scope drift.

/gsd-health --repair            # проверить и починить .planning/

Управление сессиями

AI-разработка — это не один непрерывный сеанс. Контекст сбрасывается, ты уходишь на обед, возвращаешься завтра. GSD это учитывает.

Остановка

/gsd-pause-work

Создаёт два файла:

.planning/HANDOFF.json — machine-readable state для Claude
.continue-here.md — human-readable summary для тебя

Продолжение

/gsd-resume-work

Восстанавливает полный контекст: что сделано, что осталось, какие решения приняты, где остановились.

Не помню на чём остановился

/gsd-progress

Покажет: текущая фаза, завершённые фазы, что в процессе, что делать дальше.

Навигация для тех, кто не помнит команды

/gsd-do "мне нужно добавить тесты для модуля авторизации"

/gsd-do — freeform text router. Описываешь что хочешь человеческим языком, система сама выбирает правильную команду.

/gsd-next

Не думай, что запускать — система знает, на каком ты шаге.

/gsd-help

Полный справочник команд.

/gsd-manager

Интерактивный dashboard с прогресс-барами, статусами фаз и рекомендациями.

Конфигурация: что крутить

Model profiles

Профиль	Кто получает Opus	Кто получает Sonnet	Кто получает Haiku
quality	planner, roadmapper, executor, researchers, debugger	verifier, plan-checker, mappers	—
balanced	planner	roadmapper, executor, verifier, debugger	researchers, mappers
budget	—	planner, executor, debugger	всё остальное
inherit	все используют модель текущей сессии

quality — когда квота есть и задача критична. Opus на всех decision-making позициях.

balanced — default. Opus только для планирования (архитектурные решения), Sonnet для всего остального.

budget — для объёмной или некритичной работы. Sonnet пишет код, Haiku валидирует.

inherit — все агенты используют модель сессии. Полезно для OpenRouter или non-Anthropic моделей.

Git branching

none — всё в текущую ветку (default)
phase — отдельная ветка на каждую фазу (gsd/phase-{N}-{slug})
milestone — отдельная ветка на milestone (gsd/{version}-{slug})

Для Paranoid-режима рекомендую phase. Каждая фаза — отдельная ветка, отдельный PR, изолированный review.

Workflow toggles

Полный список того, что можно включить или выключить:

Toggle	Default	Что делает
`research`	true	Research перед планированием
`plan_check`	true	Верификация планов (до 3 итераций)
`verifier`	true	Post-execution верификация
`nyquist_validation`	true	Nyquist-аудит тестов
`ui_phase`	true	UI-спецификации для фронтенда
`ui_safety_gate`	true	Предупреждение если UI-phase пропущен
`skip_discuss`	false	Пропуск discuss-phase в autonomous mode
`discuss_mode`	standard	`standard` или `assumptions`
`research_before_questions`	false	Research ДО вопросов discuss-phase

Recovery: когда что-то пошло не так

Ситуация	Команда
Потерян контекст, новая сессия	`/gsd-resume-work`
Фаза пошла криво	`/gsd-undo --phase N`, потом перепланировать
Нужно поменять scope	`/gsd-add-phase`, `/gsd-insert-phase`, `/gsd-remove-phase`
Milestone audit нашёл дыры	`/gsd-plan-milestone-gaps`
Что-то сломалось	`/gsd-debug "описание"`
STATE.md рассинхронизировался	`/gsd-health --repair`
Workflow corrupted	`/gsd-forensics`
Не знаю что делать дальше	`/gsd-next`
План не соответствует видению	`/gsd-discuss-phase N` → перепланировать
Слишком дорого	`/gsd-set-profile budget` + отключить агентов
Хочу отчёт по сессии	`/gsd-session-report`

Почему это работает

GSD решает три фундаментальные проблемы AI-разработки:

Контекстное загрязнение. Без GSD ты пишешь код в том же контекстном окне, где обсуждал требования, дебажил предыдущую фичу и гуглил документацию. К моменту написания кода модель уже наполовину галлюцинирует. GSD: оркестратор на 30–40%, каждый субагент — чистый контекст.

Отсутствие верификации. Claude скажет «готово» и будет искренне верить, что всё работает. Без проверки ты узнаешь о проблемах в продакшене. GSD: goal-backward verification, Nyquist-аудит тестов, STRIDE threat model, code review — всё автоматически.

Потеря контекста между сессиями. Закрыл терминал — потерял всё. GSD: HANDOFF.json, STATE.md, CONTEXT.md — полная persistence. /gsd-resume-work восстанавливает контекст за секунды.

Результат: ты получаешь не «AI написал код», а «AI провёл полный engineering cycle». С research, планированием, execution, тестами, security-аудитом и code review. И всё это — за одну сессию (или несколько, если проект большой), без потери контекста.

Чек-листы для копирования

Speed Run Checklist

/gsd-new-project --auto
/gsd-settings                    # budget, coarse, research off, plan_check off
/gsd-autonomous                  # или manual /gsd-next цикл
/gsd-complete-milestone

Balanced Checklist

/gsd-map-codebase               # для brownfield
/gsd-new-project
/gsd-settings                    # balanced defaults

# Per phase:
/gsd-discuss-phase N
/gsd-plan-phase N
/gsd-execute-phase N
/gsd-verify-work N              # при необходимости

# Finish:
/gsd-audit-milestone
/gsd-complete-milestone

Paranoid Checklist

/gsd-map-codebase
/gsd-new-project
/gsd-settings                    # quality, fine, phase branching, всё on

# Per phase:
/gsd-discuss-phase N --analyze
/gsd-ui-phase N                  # если фронтенд
/gsd-plan-phase N --reviews
/gsd-execute-phase N
/gsd-verify-work N
/gsd-validate-phase N
/gsd-secure-phase N
/gsd-code-review N
/gsd-code-review-fix N --auto
/gsd-review N
/gsd-ui-review N                 # если фронтенд
/gsd-ship N

# Finish:
/gsd-audit-milestone
/gsd-plan-milestone-gaps         # если audit нашёл дыры
/gsd-docs-update
/gsd-complete-milestone

Feature Addition Checklist

# Мелкая (1–3 файла):
/gsd-fast "описание"

# Средняя:
/gsd-quick --full "описание"

# Большая (в рамках milestone):
/gsd-add-phase
/gsd-discuss-phase N
/gsd-plan-phase N
/gsd-execute-phase N

# Большая (новый milestone):
/gsd-new-milestone
# далее стандартный цикл

Bug Fix Checklist

# Мелкий баг (точно знаешь где):
/gsd-fast "описание фикса"

# Средний баг (знаешь симптом):
/gsd-debug "описание проблемы"

# Баг из верификации:
/gsd-diagnose-issues
/gsd-plan-phase N --gaps
/gsd-execute-phase N --gaps-only
/gsd-verify-work N

# Баг из code review:
/gsd-code-review-fix N --auto

# Регрессия:
/gsd-undo --phase N             # или --plan N-M, или --last 5
/gsd-plan-phase N
/gsd-execute-phase N

Установка

npx get-shit-done-cc@latest

Работает на Mac, Windows, Linux. Кроме Claude Code поддерживает Codex, Gemini CLI, OpenCode, Windsurf, Kilo, Antigravity.

Обновление:

/gsd-update

Показывает changelog между текущей и новой версией ДО установки. Можно сначала посмотреть, потом решить.