Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

sprint-workflow

/sprint-workflow

Prowadzi pełny cykl sprintu (Think, Plan, Build, Review, Test, Ship, Monitor) przy nowej funkcji, refaktoryzacji lub wieloetapowym zadaniu, w trybach plan i autopilot Copilot CLI.

Licencja
MIT
Ostatnia zmiana repozytorium
25.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 25.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Prowadzi pełny cykl sprintu (Think, Plan, Build, Review, Test, Ship, Monitor) przy nowej funkcji, refaktoryzacji lub wieloetapowym zadaniu, w trybach plan i autopilot Copilot CLI.

Oryginalny opis (EN)

Use when starting a new feature, refactor, or multi-step dev task — runs the full sprint cycle (Think → Plan → Build → Review → Test → Ship → Monitor) using Copilot CLI's plan/autopilot modes.

Jak działa

  1. When to Use
  2. Prerequisites
  3. The Sprint
  4. Full Example
  5. Output Format
  6. Common Rationalizations
  7. Red Flags
  8. Verification
  9. Tips
  10. See Also
Sekcje z nagłówków SKILL.md, w oryginale · 272 linii, 1 457 słów
Podgląd SKILL.md
---
name: sprint-workflow
description: Use when starting a new feature, refactor, or multi-step dev task — runs the full sprint cycle (Think → Plan → Build → Review → Test → Ship → Monitor) using Copilot CLI's plan/autopilot modes.
metadata:
  category: workflow
---

# Sprint Workflow

A structured end-to-end development sprint using Copilot CLI's full capability stack.
Inspired by Garry Tan's gstack approach — each step feeds the next, nothing falls through.

**Think → Plan → Build → Review → Test → Ship → Monitor**

## When to Use

- Starting a new feature or significant refactor
- Any task that spans multiple files or requires sequencing
- When you want structured, reviewable output rather than ad-hoc changes
- Team environments where pull requests are the delivery mechanism

## Prerequisites

- Copilot CLI authenticated (`gh auth status`)
- For the **Review step**: standard mode (no extra setup)
- For the **sprint-retro** skill after this sprint: enable experimental features first:

  ```text
  /experimental on
  ```

  > ⚠️ `/chronicle` (used in `sprint-retro`) requires `/experimental on` to be run in the **same session**.

## The Sprint

### Step 1: Think — Frame the Problem

Before writing a line, challenge the premise:

```text
> I want to build [X]. What am I actually trying to solve?
```

Push back on your own framing. Identify:

- The real user pain (not the feature request)
- Assumptions that could be wrong
- The simplest possible version that delivers value

### Step 2: Plan — Structured Implementation Plan

Switch to **Plan Mode** (`Shift+Tab`) and describe the task:

```text
[Plan Mode]
> Implement paginated results for the /api/users endpoint
```

Copilot will ask clarifying questions, then produce a structured plan. Review it carefully.
Approve with `exit_plan_mode` when ready.

For complex tasks, prompt for explicit sections:

```text
[Plan Mode]
> Design the pagination feature. Include:
> 1. Data flow and API contract
> 2. Edge cases and error handling
> 3. Test plan (unit + integration)
> 4. Files to change and why
```

### Step 3: Build — Autopilot Execution

After plan approval, switch to **Autopilot Mode** (`Shift+Tab`) and let Copilot execute:

```text
[Autopilot Mode]
> Implement the plan
```

Copilot works autonomously. You can monitor progress or continue other work.
For parallelizable tasks (multiple independent files), use:

```text
/fleet Implement the pagination plan across all affected service files
```

### Step 4: Review — Catch Issues Before They Ship

Run the `/review` command to trigger a systematic code review:

```text
/review
```

Copilot's code-review agent surfaces only genuine issues — bugs, security holes,
logic errors. Address blockers before testing.

If you are translating this workflow back into a Claude Code or hybrid setup, Claude Code
v2.1.108+ can discover and invoke built-in review commands through its `Skill` tool instead of
relying on a human to type them manually. In Copilot CLI, keep the same intent explicit by
invoking `/review` directly or dispatching the equivalent review agent as a planned handoff.

You can also check the diff:

```text
/diff
```

### Step 5: Test — Verify the Implementation

Run the test suite and verify new tests were added:

```text
> Run the test suite and confirm all tests pass including the new pagination tests
```

For comprehensive E2E verification:

```text
> Run the full test suite. If any tests fail, analyze and fix them before continuing.
```

### Step 6: Ship — Delegate to Cloud or Create PR

**Option A: Delegate the PR creation to the cloud agent:**

```text
& "Create a PR for the pagination feature with a clear description and review checklist"
```

**Option B: Create a PR locally:**

```text
> Create a pull request for the pagination feature. Include:
> - Summary of changes
> - Testing approach
> - Screenshots or examples if applicable
```

### Step 7: Monitor — Validate the Release in a Safe Blast Radius

Shipping code is not the end of the sprint. For runtime systems, add an observation gate:

```text
> Start a post-ship canary for this release.
> Define the watch window, health signals, rollback triggers, and promotion criteria.
```

Use [`deployment-canary`](../deployment-canary/SKILL.md) when the release touches production
traffic, feature flags, or customer-facing flows. If the release is package-only, replace the
canary with a smoke verification step.

## Full Example

```text
# Step 1: Think
> We have slow API responses. I want to add caching.
> [Challenge: is caching the right fix, or is the query slow?]

# Step 2: Plan
[Plan Mode]
> Investigate the slow /api/products query, then implement the right fix.
> Include a performance benchmark before and after.

# Step 3: Build
[Autopilot Mode]
> Execute the plan.

# Step 4: Review
/review

# Step 5: Test
> Run the benchmark and confirm the performance improvement.

# Step 6: Ship
& "Create a PR: Fix slow product queries — add DB index + query optimization"

# Step 7: Monitor
> Run a canary for the release candidate. Hold or roll back if p95 latency or error rate regress.
```

## Output Format

Each step produces verifiable output:

| Step | Output | How to Verify |
|------|--------|---------------|
| Think | Written problem statement | Challenge at least one assumption |
| Plan | `plan.md` with numbered tasks + file list | Confirm scope before approving |
| Build | File changes | `/diff` — confirm only planned files changed |
| Review | `[PASS]`/`[CONCERN]`/`[BLOCK]` per category | Address all BLOCKs before continuing |
| Test | Test run output (pass count, coverage delta) | Zero regressions; new tests for new behaviour |
| Ship | PR URL + description | PR description references the plan |
| Monitor | Canary or smoke verification result | Explicitly record PROMOTE / HOLD / ROLLBACK |

### `/review` Output Interpretation

```text
✅ PASS    — No issues in this category
⚠️ CONCERN — Advisory; fix if feasible, document if not
🚫 BLOCK   — Must fix before merging

Categories: Logic, Security, Tests, Performance, API Contracts
```

### `/diff` Output Interpretation

```text
# Confirm scope is correct:
# - Only files in the plan should appear
# - No unintended deletions
# - No debug code or temporary files
```

## Common Rationalizations

| Rationalization | Reality |
|----------------|---------|
| "Skip planning, start coding now" | Sprints without a plan lose direction mid-way. An hour in Plan Mode saves three hours of rework. |
| "Reviews can wait until next sprint" | Features merged without review accumulate technical debt. Review must be part of the definition of done. |
| "Tests after the feature stabilizes" | Stabilization never comes. Once shipped, there's no time to add tests. |
| "Deadline approaching, lower the quality bar" | Low-quality 'done' features return as bugs in the next sprint. |

## Red Flags

- Sprint started without a definition of done
- Features merged within the sprint without tests
- Production-impacting releases shipped with no observation window
- Next sprint started immediately without a retrospective
- Sprint goal is missing or has too many objectives (5+)
- PRs merged directly to main without review

## Verification

- [ ] Sprint goal defined in 1–3 clear sentences
- [ ] Every task has explicit acceptance criteria
- [ ] **Plan identifiers are unique** — each TASK-/GOAL-/REQ- identifier declared exactly once (run checks below)
- [ ] All PRs merged by sprint end passed code review
- [ ] Runtime releases included a canary or smoke-monitoring step
- [ ] `sprint-retro` skill used for a data-driven retrospective
- [ ] Next sprint backlog prepared

### Plan Identifier Uniqueness Gate

Before approving a plan, verify that each `TASK-`, `GOAL-`, and `REQ-` identifier is declared
exactly once. A reference to another task (e.g., "depends on TASK-03") is not a declaration and
must not appear in the duplicate list.

```bash
# Detect duplicate declarations in table rows
grep -oE '^\| (TASK|GOAL|REQ)-[0-9]+' plan.md | sort | uniq -d

# Detect duplicate declarations in bullet lists
grep -oE '^- \*\*(TASK|GOAL|REQ)-[0-9]+' plan.md | sort | uniq -d
```

Any output from either command is a blocking error — resolve the collision before beginning the
Build step.

## Tips

- **Plan Mode is not optional** for features > 1 file. It prevents costly mid-build corrections.
- **Autopilot with full permissions** (`--yolo`) speeds up execution but review the plan carefully first.
- **`/review` before every PR** — the signal-to-noise is high, it surfaces real issues.
- **Use `/diff` to sanity-check** scope before shipping — did Copilot change more than planned?
- **Do not skip the watch window**: if the change reaches users, the sprint includes monitoring, not only PR creation.
- **Reference the plan in the PR description** — use `/session plan` to surface it.

## See Also

- [`fix-github-issue`](../../development/fix-github-issue/SKILL.md) — Issue-driven variant of this sprint workflow
- [`commit-workflow`](../commit-workflow/SKILL.md) — Conventional commit + emoji for the Ship step
- [`pr-multi-perspective-review`](../../development/pr-multi-perspective-review/SKILL.md) — Deeper 6-lens review for the Review step
- [`deployment-canary`](../deployment-canary/SKILL.md) — post-ship rollout monitoring and rollback gates
- [`sprint-retro`](../sprint-retro/SKILL.md) — Retrospective after the sprint completes

Wersje

RepozytoriumWynikLicencja
Ta strona · drvoss/everything-copilot-cli100MIT
jeremylongshore/tons-of-skills-marketplace100MIT

Migawka bazy z 13.11.2026 · wersja paczki 63b920888dc7 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 1 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100sprint
    Prowadzi sprint przez kolejne etapy planowania, budowy, testów, przeglądu i wdrożenia.
  • 91sprint-end
    Wprowadza pracę ze sprintu do gałęzi main przez pull request.
  • 100plan-sprint
    Przygotowuje plan sprintu dla nowego cyklu rozwoju, na przykład po zakończeniu poprzedniego sprintu.
  • 100spec-driven-dev
    Prowadzi agenta kodującego przez bramkowany cykl Spec, Plan, Build, Test, Review i Ship przy zmianach obejmujących wiele plików.
  • 100sprint-autopilot
    Prowadzi zgłoszenie ze sprintu Jira od analizy, przez gałąź i kod, po merge request.
  • 100ship
    Prowadzi pełny cykl rozwoju funkcji lub poprawki w do 10 fazach, od eksploracji i planu po testy, przegląd i weryfikację końcową.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.