Heim

Skill

Produktivität und Workflow

planning-and-task-breakdown

addyosmani/agent-skills

Teilen Sie die Arbeit in kleine, überprüfbare Aufgaben mit klaren Abnahmekriterien auf, die nach Abhängigkeiten geordnet und vertikal unterteilt sind, um eine zuverlässige Umsetzung zu gewährleisten.

...Alle erweitern

Zeit aktualisiert 3. September 2026

# planning # dependency graph # acceptance criteria # checkpoints # task breakdown # vertical slicing

Planung und Aufgabenaufteilung

Überblick

Gliedern Sie die Arbeit in kleine, überprüfbare Aufgaben mit eindeutigen Abnahmekriterien auf. Eine gute Aufgabengliederung macht den Unterschied zwischen einem Mitarbeiter, der seine Arbeit zuverlässig erledigt, und einem, der ein unübersichtliches Durcheinander hinterlässt. Jede Aufgabe sollte so klein sein, dass sie in einer einzigen konzentrierten Sitzung umgesetzt, getestet und überprüft werden kann.

Anwendungsfälle

Sie haben eine Spezifikation und müssen diese in umsetzbare Einheiten aufteilen
Eine Aufgabe erscheint zu groß oder zu vage, um damit zu beginnen
Die Arbeit muss über mehrere Agenten oder Sitzungen hinweg parallelisiert werden
Sie müssen den Umfang einem Menschen vermitteln
Die Reihenfolge der Umsetzung ist nicht offensichtlich

Wann man es NICHT verwenden sollte: Änderungen an einer einzigen Datei mit klarem Umfang oder wenn die Spezifikation bereits klar definierte Aufgaben enthält.

Der Planungsprozess

Schritt 1: Wechseln Sie in den Planungsmodus

Bevor Sie Code schreiben, arbeiten Sie im Lese-Modus:

Lesen Sie die Spezifikation und die relevanten Abschnitte der Codebasis
Identifizieren Sie vorhandene Muster und Konventionen
Ordnen Sie die Abhängigkeiten zwischen den Komponenten zu
Notieren Sie Risiken und Unbekannte

Schreiben Sie während der Planung KEINEN Code. Das Ergebnis ist ein Planungsdokument, keine Implementierung.

Schritt 2: Ermitteln Sie den Abhängigkeitsgraphen

Stellen Sie dar, was von was abhängt:

Datenbankschema
    │
    ├── API-Modelle/Typen
    │       │
    │       ├── API-Endpunkte
    │       │       │
    │       │       └── Frontend-API-Client
    │       │               │
    │       │               └── UI-Komponenten
    │       │
    │       └── Validierungslogik
    │
    └── Startdaten / Migrationen

Die Reihenfolge der Implementierung folgt dem Abhängigkeitsgraphen von unten nach oben: Zuerst werden die Grundlagen geschaffen.

Schritt 3: Vertikale Aufteilung

Anstatt zuerst die gesamte Datenbank, dann die gesamte API und schließlich die gesamte Benutzeroberfläche zu erstellen, sollte jeweils ein vollständiger Funktionspfad nach dem anderen entwickelt werden:

Schlecht (horizontale Aufteilung):

Aufgabe 1: Das gesamte Datenbankschema erstellen
Aufgabe 2: Alle API-Endpunkte erstellen
Aufgabe 3: Alle UI-Komponenten erstellen
Aufgabe 4: Alles miteinander verbinden

Gut (vertikale Aufteilung):

Aufgabe 1: Der Benutzer kann ein Konto erstellen (Schema + API + Benutzeroberfläche für die Registrierung)
Aufgabe 2: Der Benutzer kann sich anmelden (Authentifizierungsschema + API + Benutzeroberfläche für die Anmeldung)
Aufgabe 3: Der Benutzer kann eine Aufgabe erstellen (Aufgabenschema + API + Benutzeroberfläche für die Erstellung)
Aufgabe 4: Der Benutzer kann die Aufgabenliste anzeigen (Abfrage + API + Benutzeroberfläche für die Listenansicht)

Jeder vertikale Abschnitt liefert funktionsfähige, testbare Funktionalität.

Schritt 4: Aufgaben erstellen

Jede Aufgabe folgt dieser Struktur:

## Aufgabe [N]: [Kurzer, beschreibender Titel]

**Beschreibung:** Ein Absatz, der erklärt, was diese Aufgabe bewirkt.

**Abnahmekriterien:**
- [ ] [Spezifische, testbare Bedingung]
- [ ] [Spezifische, testbare Bedingung]

**Verifizierung:**
- [ ] Tests bestehen: `npm test -- --grep "feature-name"`
- [ ] Build erfolgreich: `npm run build`
- [ ] Manuelle Überprüfung: [Beschreibung dessen, was zu überprüfen ist]

**Abhängigkeiten:** [Aufgabennummern, von denen diese Aufgabe abhängt, oder „Keine“]

**Möglicherweise betroffene Dateien:**
- `src/Pfad/zur/Datei.ts`
- `tests/Pfad/zum/Test.ts`

**Geschätzter Umfang:** [Klein: 1–2 Dateien | Mittel: 3–5 Dateien | Groß: 5+ Dateien]

Schritt 5: Reihenfolge und Kontrollpunkt

Ordnen Sie die Aufgaben so an, dass:

die Abhängigkeiten erfüllt sind (zuerst die Grundlage schaffen)
Jede Aufgabe das System in einem funktionsfähigen Zustand hinterlässt
Nach jeweils 2–3 Aufgaben finden Verifizierungs-Checkpoints statt
risikoreiche Aufgaben frühzeitig durchgeführt werden (schnelles Erkennen von Fehlern)

Fügen Sie explizite Kontrollpunkte hinzu:

## Kontrollpunkt: Nach den Aufgaben 1–3
- [ ] Alle Tests sind bestanden
- [ ] Die Anwendung lässt sich fehlerfrei erstellen
- [ ] Der zentrale Benutzerablauf funktioniert durchgängig
- [ ] Vor dem Fortfahren durch eine Person überprüfen lassen

Richtlinien zur Aufgabengrößenbestimmung

Umfang	Dateien	Umfang	Beispiel
XS	1	Einzelne Funktions- oder Konfigurationsänderung	Hinzufügen einer Validierungsregel
S	1–2	Eine Komponente oder ein Endpunkt	Einen neuen API-Endpunkt hinzufügen
M	3–5	Ein Feature-Slice	Ablauf der Benutzerregistrierung
L	5–8	Funktionskomponente mit mehreren Komponenten	Suche mit Filterung und Paginierung
XL	8+	Zu groß – weiter aufschlüsseln	—

Wenn eine Aufgabe L oder größer ist, sollte sie in kleinere Aufgaben unterteilt werden. Ein Bearbeiter erbringt bei S- und M-Aufgaben die beste Leistung.

Wann sollte eine Aufgabe weiter unterteilt werden:

Es würde mehr als eine konzentrierte Arbeitssitzung erfordern (etwa 2+ Stunden Arbeitszeit eines Mitarbeiters)
Die Abnahmekriterien lassen sich nicht in drei oder weniger Stichpunkten beschreiben
Sie betrifft zwei oder mehr unabhängige Teilsysteme (z. B. Authentifizierung und Abrechnung)
Sie stellen fest, dass Sie im Aufgabentitel „und“ schreiben (ein Zeichen dafür, dass es sich um zwei Aufgaben handelt)

Vorlage für ein Planungsdokument

# Implementierungsplan: [Feature-/Projektname]

## Überblick
[Zusammenfassung in einem Absatz darüber, was wir entwickeln]

## Architekturentscheidungen
- [Wichtige Entscheidung 1 und Begründung]
- [Wichtige Entscheidung 2 und Begründung]

## Aufgabenliste

### Phase 1: Grundlagen
- [ ] Aufgabe 1: ...
- [ ] Aufgabe 2: ...

### Meilenstein: Grundlagen
- [ ] Tests bestanden, Builds fehlerfrei

### Phase 2: Kernfunktionen
- [ ] Aufgabe 3: ...
- [ ] Aufgabe 4: ...

### Meilenstein: Kernfunktionen
- [ ] End-to-End-Ablauf funktioniert

### Phase 3: Feinschliff
- [ ] Aufgabe 5: ...
- [ ] Aufgabe 6: ...

### Meilenstein: Fertigstellung
- [ ] Alle Abnahmekriterien erfüllt
- [ ] Bereit zur Überprüfung

## Risiken und Gegenmaßnahmen
| Risiko | Auswirkung | Gegenmaßnahme |
|------|--------|------------|
| [Risiko] | [Hoch/Mittel/Niedrig] | [Strategie] |

## Offene Fragen
- [Frage, die menschliche Eingabe erfordert]

Möglichkeiten zur Parallelisierung

Wenn mehrere Agenten oder Sitzungen verfügbar sind:

Sicher zu parallelisieren: Unabhängige Feature-Slices, Tests für bereits implementierte Features, Dokumentation
Müssen sequenziell erfolgen: Datenbankmigrationen, Änderungen am gemeinsamen Zustand, Abhängigkeitsketten
Koordination erforderlich: Funktionen, die einen gemeinsamen API-Vertrag nutzen (zuerst den Vertrag definieren, dann parallelisieren)

Häufige Rationalisierungen

Begründung	Realität
„Das werde ich schon im Laufe der Arbeit herausfinden“	So landet man am Ende in einem Wirrwarr und muss Nacharbeit leisten. 10 Minuten Planung sparen Stunden.
„Die Aufgaben sind offensichtlich“	Schreib sie trotzdem auf. Explizite Aufgaben decken versteckte Abhängigkeiten und vergessene Sonderfälle auf.
„Planung ist Mehraufwand“	Planung ist die Aufgabe. Die Umsetzung ohne Plan ist bloßes Tippen.
„Ich kann mir das alles merken“	Kontextfenster sind begrenzt. Schriftliche Pläne überdauern Sitzungsgrenzen und Komprimierung.

Warnsignale

Mit der Umsetzung beginnen, ohne eine schriftliche Aufgabenliste zu haben
Aufgaben, die nur „die Funktion umsetzen“ lauten, ohne Abnahmekriterien
Keine Verifizierungsschritte im Plan
Alle Aufgaben sind XL-groß
Keine Meilensteine zwischen den Aufgaben
Die Reihenfolge der Abhängigkeiten wird nicht berücksichtigt

Verifizierung

Bevor Sie mit der Umsetzung beginnen, stellen Sie Folgendes sicher:

Jede Aufgabe verfügt über Akzeptanzkriterien
Jede Aufgabe verfügt über einen Verifizierungsschritt
Die Abhängigkeiten zwischen den Aufgaben sind identifiziert und korrekt geordnet
Keine Aufgabe betrifft mehr als ~5 Dateien
Zwischen den Hauptphasen gibt es Meilensteine
Der zuständige Mitarbeiter hat den Plan geprüft und genehmigt

Siehe auch

Akzeptanzkriterien gelten pro Aufgabe und beantworten die Frage „Haben wir das Richtige erstellt?“. Sie stehen über der projektweiten „Definition of Done“ – der Messlatte, die jede Aufgabe überspringen muss, bevor sie als erledigt gilt. Siehe references/definition-of-done.md.

Auf GitHub ansehen

---
name: planning-and-task-breakdown
description: Decompose work into small, verifiable tasks with explicit acceptance criteria, ordered by dependencies and sliced vertically for reliable implementation.
---

# Planning and Task Breakdown

## Overview

Decompose work into small, verifiable tasks with explicit acceptance criteria. Good task breakdown is the difference between an agent that completes work reliably and one that produces a tangled mess. Every task should be small enough to implement, test, and verify in a single focused session.

## When to Use

- You have a spec and need to break it into implementable units
- A task feels too large or vague to start
- Work needs to be parallelized across multiple agents or sessions
- You need to communicate scope to a human
- The implementation order isn't obvious

**When NOT to use:** Single-file changes with obvious scope, or when the spec already contains well-defined tasks.

## The Planning Process

### Step 1: Enter Plan Mode

Before writing any code, operate in read-only mode:

- Read the spec and relevant codebase sections
- Identify existing patterns and conventions
- Map dependencies between components
- Note risks and unknowns

**Do NOT write code during planning.** The output is a plan document, not implementation.

### Step 2: Identify the Dependency Graph

Map what depends on what:

```
Database schema
    │
    ├── API models/types
    │       │
    │       ├── API endpoints
    │       │       │
    │       │       └── Frontend API client
    │       │               │
    │       │               └── UI components
    │       │
    │       └── Validation logic
    │
    └── Seed data / migrations
```

Implementation order follows the dependency graph bottom-up: build foundations first.

### Step 3: Slice Vertically

Instead of building all the database, then all the API, then all the UI — build one complete feature path at a time:

**Bad (horizontal slicing):**
```
Task 1: Build entire database schema
Task 2: Build all API endpoints
Task 3: Build all UI components
Task 4: Connect everything
```

**Good (vertical slicing):**
```
Task 1: User can create an account (schema + API + UI for registration)
Task 2: User can log in (auth schema + API + UI for login)
Task 3: User can create a task (task schema + API + UI for creation)
Task 4: User can view task list (query + API + UI for list view)
```

Each vertical slice delivers working, testable functionality.

### Step 4: Write Tasks

Each task follows this structure:

```markdown
## Task [N]: [Short descriptive title]

**Description:** One paragraph explaining what this task accomplishes.

**Acceptance criteria:**
- [ ] [Specific, testable condition]
- [ ] [Specific, testable condition]

**Verification:**
- [ ] Tests pass: `npm test -- --grep "feature-name"`
- [ ] Build succeeds: `npm run build`
- [ ] Manual check: [description of what to verify]

**Dependencies:** [Task numbers this depends on, or "None"]

**Files likely touched:**
- `src/path/to/file.ts`
- `tests/path/to/test.ts`

**Estimated scope:** [Small: 1-2 files | Medium: 3-5 files | Large: 5+ files]
```

### Step 5: Order and Checkpoint

Arrange tasks so that:

1. Dependencies are satisfied (build foundation first)
2. Each task leaves the system in a working state
3. Verification checkpoints occur after every 2-3 tasks
4. High-risk tasks are early (fail fast)

Add explicit checkpoints:

```markdown
## Checkpoint: After Tasks 1-3
- [ ] All tests pass
- [ ] Application builds without errors
- [ ] Core user flow works end-to-end
- [ ] Review with human before proceeding
```

## Task Sizing Guidelines

| Size | Files | Scope | Example |
|------|-------|-------|---------|
| **XS** | 1 | Single function or config change | Add a validation rule |
| **S** | 1-2 | One component or endpoint | Add a new API endpoint |
| **M** | 3-5 | One feature slice | User registration flow |
| **L** | 5-8 | Multi-component feature | Search with filtering and pagination |
| **XL** | 8+ | **Too large — break it down further** | — |

If a task is L or larger, it should be broken into smaller tasks. An agent performs best on S and M tasks.

**When to break a task down further:**
- It would take more than one focused session (roughly 2+ hours of agent work)
- You cannot describe the acceptance criteria in 3 or fewer bullet points
- It touches two or more independent subsystems (e.g., auth and billing)
- You find yourself writing "and" in the task title (a sign it is two tasks)

## Plan Document Template

```markdown
# Implementation Plan: [Feature/Project Name]

## Overview
[One paragraph summary of what we're building]

## Architecture Decisions
- [Key decision 1 and rationale]
- [Key decision 2 and rationale]

## Task List

### Phase 1: Foundation
- [ ] Task 1: ...
- [ ] Task 2: ...

### Checkpoint: Foundation
- [ ] Tests pass, builds clean

### Phase 2: Core Features
- [ ] Task 3: ...
- [ ] Task 4: ...

### Checkpoint: Core Features
- [ ] End-to-end flow works

### Phase 3: Polish
- [ ] Task 5: ...
- [ ] Task 6: ...

### Checkpoint: Complete
- [ ] All acceptance criteria met
- [ ] Ready for review

## Risks and Mitigations
| Risk | Impact | Mitigation |
|------|--------|------------|
| [Risk] | [High/Med/Low] | [Strategy] |

## Open Questions
- [Question needing human input]
```

## Parallelization Opportunities

When multiple agents or sessions are available:

- **Safe to parallelize:** Independent feature slices, tests for already-implemented features, documentation
- **Must be sequential:** Database migrations, shared state changes, dependency chains
- **Needs coordination:** Features that share an API contract (define the contract first, then parallelize)

## Common Rationalizations

| Rationalization | Reality |
|---|---|
| "I'll figure it out as I go" | That's how you end up with a tangled mess and rework. 10 minutes of planning saves hours. |
| "The tasks are obvious" | Write them down anyway. Explicit tasks surface hidden dependencies and forgotten edge cases. |
| "Planning is overhead" | Planning is the task. Implementation without a plan is just typing. |
| "I can hold it all in my head" | Context windows are finite. Written plans survive session boundaries and compaction. |

## Red Flags

- Starting implementation without a written task list
- Tasks that say "implement the feature" without acceptance criteria
- No verification steps in the plan
- All tasks are XL-sized
- No checkpoints between tasks
- Dependency order isn't considered

## Verification

Before starting implementation, confirm:

- [ ] Every task has acceptance criteria
- [ ] Every task has a verification step
- [ ] Task dependencies are identified and ordered correctly
- [ ] No task touches more than ~5 files
- [ ] Checkpoints exist between major phases
- [ ] The human has reviewed and approved the plan

## See Also

Acceptance criteria are per-task and answer "did we build the right thing?". They sit on top of the project-wide Definition of Done, the standing bar every task clears before it counts as done. See `references/definition-of-done.md`.

Alle Dateien

0 Dateien

planning-and-task-breakdown installieren

Laden Sie die Skill-Dateien herunter und entpacken Sie sie in Ihr Verzeichnis „.claude/skills/“.

ZIP herunterladen

Klonen Sie das Repository und kopieren Sie die Skill-Dateien in Ihr Projekt.

git clone https://github.com/addyosmani/agent-skills/tree/main/skills/planning-and-task-breakdown # Copy SKILL.md to your .claude/skills/ directory

Kopieren

Schnelle Einrichtung: Kopiere den Skill-Ordner nach .claude/skills/ Claude erkennt den Skill automatisch und nutzt ihn.

Repository addyosmani/agent-skills