plan-tracking
/plan-tracking
Pilnuje, by postęp zadań był zapisywany w samym pliku planu, a nie tylko w pamięci agenta.
- Repozytorium
- humansintheloop-dev-workflow-and-tools ↗
- Licencja
- Apache-2.0
- Ostatnia zmiana repozytorium
- 26.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 26.10.2026, bez odwołań do wycofanych modeli i API.
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
- Core Rule
- ⚠️ Verifying Observable and Evidence (CRITICAL - READ THIS)
- Migration Planning
- Review Plans for Technical Correctness
- Workflow
- Continue Without Stopping
- Why This Matters
- Common Mistake
- When to Apply
- Commit Guidelines
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.