Przejdź do treści
Biblioteka skilli
Zarządzanie i produkt · Automatyzacja

plan-tracking

/plan-tracking

Pilnuje, by postęp zadań był zapisywany w samym pliku planu, a nie tylko w pamięci agenta.

Licencja
Apache-2.0
Ostatnia zmiana repozytorium
26.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 26.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Pilnuje, by postęp zadań był zapisywany w samym pliku planu, a nie tylko w pamięci agenta.

Oryginalny opis (EN)

Guidelines for working with plan files. Claude should use this skill when the user provides a plan file (e.g., *-plan.md) to ensure task completion is tracked in the plan file itself, not just internally.

Jak działa

  1. Core Rule
  2. ⚠️ Verifying Observable and Evidence (CRITICAL - READ THIS)
  3. Migration Planning
  4. Review Plans for Technical Correctness
  5. Workflow
  6. Continue Without Stopping
  7. Why This Matters
  8. Common Mistake
  9. When to Apply
  10. Commit Guidelines
Sekcje z nagłówków SKILL.md, w oryginale · 148 linii, 788 słów
Podgląd SKILL.md
---
name: plan-tracking
description: Guidelines for working with plan files. Claude should use this skill when the user provides a plan file (e.g., *-plan.md) to ensure task completion is tracked in the plan file itself, not just internally.
---

# Plan File Tracking Guidelines

When working from a plan file (markdown file with task checkboxes), follow these guidelines to ensure proper tracking.

## Core Rule

**The plan file is the source of truth for task completion status.**

Use the `plan-file-management` skill's subcommands to read and update plan files:
- **Find next task**: `plan-file-management` → `get-next-task`
- **Mark task complete**: `plan-file-management` → `mark-task-complete`

See the `plan-file-management` skill for invocation details.

Do NOT rely on internal tracking (like TodoWrite) as a substitute for updating the actual plan file.

## ⚠️ Verifying Observable and Evidence (CRITICAL - READ THIS)

**THIS IS THE MOST IMPORTANT SECTION OF THIS SKILL.**

**A task is NOT complete until the Observable outcome is actually observed and the Evidence is actually collected.**

If a task has these fields:
- **Observable**: What should be true after the task is complete
- **Evidence**: How to verify the observable

Then **tests** must verify the Evidence - not the agent manually running commands and checking output.

This applies to all test types:
- JUnit/unit tests
- Integration tests
- Component tests
- Shell test scripts

Example task:
```
- [ ] **Task 1.3: POST /orders endpoint creates order and returns 201**
  - Observable: Endpoint accepts order JSON, persists to database, returns 201 with order ID
  - Evidence: Integration test POSTs valid order, asserts 201 response, asserts order exists in database
```

The test must contain assertions that verify the Evidence:
```java
@Test
void createOrder_returnsCreatedWithOrderId() {
    var response = restTemplate.postForEntity("/orders", validOrderRequest, OrderResponse.class);

    assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
    assertThat(response.getBody().getId()).isNotNull();

    // Verify persisted to database
    var saved = orderRepository.findById(response.getBody().getId());
    assertThat(saved).isPresent();
    assertThat(saved.get().getCustomerId()).isEqualTo(validOrderRequest.getCustomerId());
}
```

WRONG: Agent writes the endpoint code, assumes it works because the code looks right
RIGHT: Tests contain assertions for the Evidence criteria; tests pass = Evidence verified

**Tests are the source of truth for verification, not the agent's judgment.**

## Migration Planning

When creating migration or upgrade plans for existing codebases:
1. Before describing any file/directory creation tasks, verify whether the target already exists using Glob or Read
2. Use precise language: "Transform" or "Convert" for existing items, "Create" only for genuinely new items
3. Include a "Current State" section in plans that documents what exists before transformation

## Review Plans for Technical Correctness

Before implementing a task from the plan, review its implementation details for technical flaws:

- Apply fundamental engineering principles (e.g., uniqueness constraints belong at database level, not application level)
- If the plan specifies a flawed approach, fix it before proceeding
- Do not blindly follow implementation details that violate best practices

## Workflow

For each task in the plan:

1. Get the next task using `plan-file-management` → `get-next-task`
2. **Review for technical correctness** before implementing
3. Implement the task (write test, implement code, verify)
4. **Verify Observable and Evidence criteria** - tests must pass that verify the Evidence (see critical section above)
5. **Mark task complete* using `plan-file-management` → `mark-task-complete`
6. Continue to the next task

## Continue Without Stopping

When implementing a documented plan:
- Continue through all phases without stopping for confirmation
- Only pause if blocked, uncertain about requirements, or encountering errors
- The plan itself serves as the user's approval to proceed
- Summarize progress periodically but don't ask "should I continue?"

## Why This Matters

- The plan file is visible to the user and persists across sessions
- Internal tracking (TodoWrite) is ephemeral and not visible in the codebase
- Commits should include both the implementation AND the updated plan
- Other developers can see progress by looking at the plan file

## Common Mistake

BAD:
```
Complete task 1.1
Update internal TodoWrite
Complete task 1.2
Update internal TodoWrite
... (plan file never updated)
```

GOOD:
```
Complete task 1.1
Use plan-file-management → mark-task-complete for thread 1, task 1
Complete task 1.2
Use plan-file-management → mark-task-complete for thread 1, task 2
```

## When to Apply

Apply this guideline when:
- User provides a plan file path (e.g., `*-plan.md`, `*-tasks.md`)
- User says "follow the plan" or "implement from the plan"
- Working with any markdown file containing `- [ ]` task checkboxes

## Commit Guidelines

When committing completed tasks:
1. Stage the implementation changes
2. Stage the updated plan file (with checkbox marked)
3. Commit together so the commit reflects both the work done and the progress tracked

## Commit Verification for Plan Files

Before running `git commit`, always:
1. Run `git status` from the **repository root** (not a subdirectory)
2. Verify the plan file appears in "Changes to be committed"
3. If the plan file is not staged, explicitly add it: `git add path/to/plan.md`

When committing from a subdirectory:
- Use absolute paths or navigate to repo root first
- Example: `git add /path/to/plan.md` or `cd /repo/root && git add .`

Wersje

W bazie nie ma innych skilli o nazwie plan-tracking.

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

Pobrania w ostatnich 30 dniach: 0 · ranking

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

Podobne skille

  • 100plan-only
    Przygotowuje plan zmiany i zapisuje go do pliku, ale nie uruchamia wykonania przed zatwierdzeniem.
  • 84review-tasks
    Przegląda plan zadań wdrożeniowych względem propozycji, specyfikacji i planu testów, zgłaszając tylko błędy poprawialne w plikach zadań.
  • 100plan-it
    Tworzy plan implementacji dla zadań obejmujących wiele plików lub domen i przekazuje go do przeglądu.
  • 100planprocess
    Wykonuje zatwierdzony plan krok po kroku z procesem oczekiwania, śledzeniem zadań i weryfikacją przed każdym oświadczeniem o ukończeniu.
  • 100run-plan
    Wykonuje gotowy plan z pliku, także wtedy, gdy trzeba wznowić go w połowie, bez pisania planu od nowa.
  • 90finalize-plan
    Sprawdza kompletność planu przed akceptacją: czy kluczowe decyzje, nazwy plików, polecenia i ograniczenia trafiły do pliku planu.

Uwagi i zgłoszenia

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