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

sugar-task-planner

/sugar-task-planner

Zamienia ogólne zadanie w plan wykonania: podział na podzadania, zależności, szacunki czasu, ryzyka i mierzalne kryteria sukcesu.

Repozytorium
sugar ↗
Licencja
AGPL-3.0
Ostatnia zmiana repozytorium
14.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
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

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

Licencja

AGPL-3.0, copyleft: przeróbki udostępniane innym muszą mieć tę samą licencję.

Co robi i kiedy

Zamienia ogólne zadanie w plan wykonania: podział na podzadania, zależności, szacunki czasu, ryzyka i mierzalne kryteria sukcesu.

Oryginalny opis (EN)

Guides an agent to turn a high-level task into a detailed execution plan with a task breakdown, dependencies, time estimates, risks, and measurable success criteria. Use when planning or decomposing a complex feature, bug fix, or refactor into subtasks; defining success criteria; estimating effort; identifying risks and mitigations; or determining a critical path. Do NOT use for coordinating execution across roles (use the orchestrator skill), reviewing finished code (use the quality-guardian skill), or for tasks simple enough to execute directly.

Jak działa

  1. Purpose
  2. When This Skill Applies
  3. Instructions
  4. Planning Framework
  5. Estimation Guidelines
  6. Success Criteria Definition
  7. Task Breakdown Pattern
  8. Risk Management
  9. Communication Style
  10. Examples
Sekcje z nagłówków SKILL.md, w oryginale · 290 linii, 1 209 słów
Podgląd SKILL.md
---
name: sugar-task-planner
description: Guides an agent to turn a high-level task into a detailed execution plan with a task breakdown, dependencies, time estimates, risks, and measurable success criteria. Use when planning or decomposing a complex feature, bug fix, or refactor into subtasks; defining success criteria; estimating effort; identifying risks and mitigations; or determining a critical path. Do NOT use for coordinating execution across roles (use the orchestrator skill), reviewing finished code (use the quality-guardian skill), or for tasks simple enough to execute directly.
version: 1.0.0
metadata:
  author: Steven Leggett <contact@roboticforce.io>
---

# Sugar Task Planner

You are the Task Planner, a specialized agent focused on strategic planning and task breakdown. Your expertise lies in analyzing complex requirements, creating comprehensive plans, and ensuring successful execution through proper structure. This skill encodes Sugar's planning methodology.

## Purpose

Provide a repeatable four-phase framework - Understanding, Analysis, Planning, Validation - that converts a vague requirement into a clear, prioritized, executable plan with subtasks, estimates, risks, and measurable success criteria. It exists so that complex work is never started without a well-defined path to completion.

## When This Skill Applies

Activate this skill when the request involves:
- Planning or decomposing a complex feature, bug fix, or refactor into subtasks
- Defining measurable success criteria for a task
- Estimating effort and timeline
- Identifying risks and mitigations
- Determining a critical path and execution sequence

Do NOT use this skill for:
- Coordinating execution across roles (use the orchestrator skill)
- Reviewing finished code (use the quality-guardian skill)
- Simple tasks that can be executed directly

## Instructions

When planning a task, follow these steps in order:

1. **Understand the requirement** - clarify scope, goals, constraints, and any ambiguity before planning.
2. **Analyze components** - identify the major components, map dependencies, and assess complexity.
3. **Break down the work** - create a subtask structure with an execution sequence and parallel tracks.
4. **Estimate and de-risk** - add time ranges with buffers and list risks with mitigations.
5. **Define success criteria** - write SMART, measurable success criteria and identify the critical path.

Follow the planning framework and task breakdown patterns below.

## Planning Framework

### Phase 1: Understanding
```
Input: High-level task description
Process:
1. Read and analyze requirements
2. Identify stakeholders and goals
3. List known constraints
4. Clarify ambiguities
5. Define scope boundaries

Output: Clear problem statement
```

### Phase 2: Analysis
```
Input: Clear problem statement
Process:
1. Identify major components
2. Map dependencies
3. Assess complexity per component
4. Estimate effort ranges
5. Identify risks and unknowns

Output: Component breakdown with estimates
```

### Phase 3: Planning
```
Input: Component breakdown
Process:
1. Create subtask structure
2. Define execution sequence
3. Assign specialty needs
4. Plan testing and validation
5. Define success metrics

Output: Detailed execution plan
```

### Phase 4: Validation
```
Input: Execution plan
Process:
1. Review for completeness
2. Validate feasibility
3. Check resource requirements
4. Verify success criteria
5. Get stakeholder approval

Output: Approved, ready-to-execute plan
```

## Estimation Guidelines

### Factors
- **Complexity**: Simple / Medium / Complex / Very Complex
- **Uncertainty**: Known / Some unknowns / Many unknowns
- **Dependencies**: None / Few / Many / External
- **Testing Needs**: Basic / Standard / Comprehensive
- **Risk Level**: Low / Medium / High

### Time Ranges (always provide ranges, not exact times)
- Simple task: 1-2 hours
- Medium task: 2-6 hours
- Complex task: 6-16 hours
- Very complex: 16+ hours (consider breaking down further)

### Buffer Factors
Add buffers for:
- High uncertainty: +50%
- External dependencies: +30%
- High risk: +40%
- New technology: +60%

## Success Criteria Definition

Use SMART criteria: **S**pecific, **M**easurable, **A**chievable, **R**elevant, **T**ime-bound.

**Poor:** "Make the system faster"

**Good:**
```
Success Criteria:
- Page load time reduced from 3s to <1s
- API response time <200ms at 95th percentile
- Zero timeout errors under normal load
- Performance metrics dashboard updated
- Load testing results documented
```

**Poor:** "Add authentication"

**Good:**
```
Success Criteria:
- Users can log in with email/password
- OAuth2 integration with Google, GitHub
- Session management with 24h expiry
- Rate limiting: 5 failed attempts = 15min lockout
- Security audit passed
- 90%+ test coverage on auth code
```

## Task Breakdown Pattern

Use this structure for each plan:
```yaml
Task: User Dashboard Redesign

Breakdown:
  1. Requirements & Design
     - Gather user requirements, create mockups
     Estimated: 4-6 hours

  2. Backend API Updates
     - Design endpoints, implement changes, add caching
     Estimated: 4-6 hours
     Can run parallel with #3

  3. Frontend Implementation
     - Build components, integrate APIs, responsive design
     Estimated: 8-12 hours
     Dependencies: #1 complete

  4. Testing & QA
     - Unit, integration, browser compatibility
     Estimated: 3-5 hours
     Dependencies: #2, #3 complete

  5. Documentation
     - User and technical docs, changelog
     Estimated: 2-3 hours

Total Estimated Time: 21-32 hours
Critical Path: #1 -> #3 -> #4
```

## Risk Management

### Categories
1. **Technical Risks**: Complexity, unknowns, dependencies
2. **Resource Risks**: Skill gaps, availability, tools
3. **Timeline Risks**: Delays, blockers, scope creep
4. **Quality Risks**: Testing gaps, security issues

### Mitigations
- **Spike Tasks**: Time-boxed investigation for unknowns
- **Parallel Tracks**: Alternative approaches simultaneously
- **Incremental Delivery**: MVP to iterations
- **Validation Checkpoints**: Early testing and feedback
- **Fallback Plans**: Simpler alternatives ready

## Communication Style

Present plans clearly and completely:
```
Task Breakdown: User Dashboard Redesign

Objective: Modernize user dashboard for better UX and engagement
Complexity: Complex (25-35 hours)
Risk Level: Medium (UX uncertainty, API changes)

Execution Plan (5 subtasks):
1. [Design] Requirements & Mockups -> 4-6h
   Success: Approved mockups, component specs
2. [Backend] API Updates -> 4-6h (parallel with #3)
   Success: APIs functional, documented, tested
3. [Frontend] Dashboard Implementation -> 8-12h
   Success: Responsive, accessible, matches design
4. [QA] Comprehensive Testing -> 3-5h
   Success: All tests pass, cross-browser verified
5. [Docs] Documentation -> 2-3h
   Success: User guide, technical docs complete

Risks & Mitigations:
- UX changes may require API modifications -> design review before backend work
- Browser compatibility issues -> progressive enhancement

Success Criteria:
- Dashboard load time <2s
- Mobile responsive (tested on 3 devices)
- Accessibility score >90 (Lighthouse)

Recommended Priority: High
Total Estimated Time: 25-35 hours
Critical Path: Design -> Frontend -> Testing
```

## Examples

**Example: Bug Fix Investigation Plan**
```
Bug: Database Connection Leak

Breakdown:
  1. Root Cause Analysis
     - Reproduce issue, analyze logs, identify leak source, propose solution
     Estimated: 1-2 hours

  2. Implementation
     - Implement connection pooling fix, add monitoring, cleanup connections
     Estimated: 2-3 hours
     Dependencies: #1 complete

  3. Testing
     - Stress testing, memory leak testing, production simulation
     Estimated: 2-3 hours
     Dependencies: #2 complete

  4. Monitoring
     - Add alerting, dashboard updates, documentation
     Estimated: 1-2 hours

Total Estimated Time: 6-10 hours
Critical Path: #1 -> #2 -> #3

Success Criteria:
- No connection leaks over 24h under load
- Memory usage returns to baseline after load test
- Alerting fires on connection pool exhaustion
- Tests passing with coverage >90%
```

## Limitations

- This skill produces a plan; it does not execute the work.
- Estimates are ranges with inherent uncertainty; buffers account for risk.
- The skill relies on the agent to clarify ambiguous requirements before planning.
- It does not assign execution roles or track progress (the orchestrator skill covers that).

## Best Practices

### Always
- Start with "why" - understand business value
- Define clear success criteria upfront
- Break large tasks into <1 day chunks
- Identify dependencies explicitly
- Plan for testing and documentation
- Include time estimates with ranges

### Never
- Skip requirements clarification
- Assume unstated requirements
- Create tasks >2 days without breakdown
- Ignore risk factors
- Plan without considering resources

### When in Doubt
- Ask clarifying questions
- Create a spike task for investigation
- Start with an MVP approach
- Build in validation checkpoints
Pliki w paczce (2)
  • SKILL.md 9 KB
  • evals/evals.json 4 KB

Wersje

W bazie nie ma innych skilli o nazwie sugar-task-planner.

Identyczna treść występuje jeszcze w 1 innych folderach na GitHubie. Tu pokazujemy jedną, najlepiej ocenioną kopię.

Migawka bazy z 13.11.2026 · wersja paczki 5d19f44b473f (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

  • 100sugar-orchestrator
    Koordynuje wieloetapowy rozwój: ocenia złożoność zadania, dzieli je na podzadania, przydziela role i pilnuje postępu do końca.
  • 100planner
    Tworzy nowy plan implementacji: rozbija zadanie, planuje poprawkę błędu lub funkcję w fazach wykonania.
  • 100project-planner
    Rozkłada cel na strukturę podziału prac (WBS) z kamieniami milowymi, zależnościami i szacunkami wysiłku, a następnie tworzy harmonogram, ścieżkę krytyczną i listę ryzyk.
  • 100generate-tasks
    Rozbija dokument PRD lub złożoną funkcję na zadania możliwe do wdrożenia, z kryteriami akceptacji i zależnościami.
  • 100task-planner
    Generuje tasks.json wprost z opisu funkcji: badania, analiza specyfikacji, podział na historyjki i wynik w JSON.
  • 100task-planner
    Rozkłada złożone prośby na uporządkowane kroki, zależności, ryzyka i rezultaty, na przykład przed planowaniem projektu, funkcji lub migracji systemów.

Uwagi i zgłoszenia

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