Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

panda-plan

/panda-plan

Tworzy plan implementacji na podstawie wymagań i istniejącego kodu: uporządkowane zadania, zależności, kryteria akceptacji, ryzyka i weryfikację.

Repozytorium
panda-suite ↗
Licencja
MIT
Ostatnia zmiana repozytorium
13.11.2026

Ocena i bezpieczeństwo

90/ 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ść25 / 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 13.11.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

Tworzy plan implementacji na podstawie wymagań i istniejącego kodu: uporządkowane zadania, zależności, kryteria akceptacji, ryzyka i weryfikację.

Oryginalny opis (EN)

Create engineering implementation plans from requirements and existing source when the user needs ordered tasks, dependencies, acceptance criteria, risks, and verification before execution.

Jak działa

  1. Inputs and workflow
  2. Output and completion
  3. Execution handoff
  4. Success discipline
Sekcje z nagłówków SKILL.md, w oryginale · 132 linii, 1 254 słów
Podgląd SKILL.md
---
name: panda-plan
description: Create engineering implementation plans from requirements and existing source when the user needs ordered tasks, dependencies, acceptance criteria, risks, and verification before execution.
---

# Panda Plan

Convert agreed requirements into work an engineer can execute. Exploration of an
unclear product need belongs before planning; a technical contract alone is a
specification, not an execution plan.

## Inputs and workflow

Use the requirements, repository, constraints, and requested scope. An existing
design or spec is optional. If source is unavailable, identify the affected
unknowns and label any proposed file layout as provisional.

1. **Understand requirements.** Extract the intended behavior, non-goals,
   compatibility promises, and acceptance conditions. Resolve ambiguities that
   materially change the plan; record smaller assumptions visibly.
2. **Inspect the system.** Read relevant source, callers, tests, configuration,
   and project instructions. Find existing patterns and capabilities before
   introducing components. Cite paths for current behavior.
3. **Define scope and dependencies.** Identify affected interfaces, data and
   transaction boundaries, integrations, and deployment concerns where relevant.
   Separate known existing contracts from design proposals and open decisions.
   When requirements span independent subsystems, propose one plan per subsystem,
   each yielding working, testable software.
4. **Order coherent tasks.** Follow real dependencies. Use milestones only for
   meaningful deliverable boundaries. Each task contains an objective, relevant
   files/components if known, prerequisites, concrete acceptance criteria, and
   verification. Include migrations, rollback/recovery, and observability only
   where the change needs them. Size a task so it ends in an independently
   testable deliverable: fold setup, configuration, and documentation into the
   task that needs them, and split only where a reviewer could accept one part
   and reject the other. When later tasks depend on earlier ones, give each task
   an interfaces note: what it consumes and produces, with exact names and
   signatures, because an implementer may see only their own task.
5. **Write decisions, not code.** Each step lets the implementer write exactly
   one reasonable thing. A test step names the test and its assertions with the
   requirement's exact values; a code step names the file, signature, and pinned
   values, with a body only for an algorithm the signature and tests leave open;
   a verification step names the command and the result that means success.
   Replace lines that decide nothing ("TBD", "handle edge cases", "add
   validation", a type no task defines). A plan longer than the code it describes
   has written the code instead.
6. **Check the plan.** Map every requirement to a task and every material risk to
   a check or explicit unresolved decision. Check that names, types, and
   signatures used in later tasks match where they are defined. Check proposed signatures against
   promised error outcomes. Confirm tests can detect the intended
   behavior and important regressions. Do not invent commands without checking
   the repository; mark proposed commands or unavailable checks accurately.
   Where omission, null, empty, and invalid values have different outcomes,
   specify them separately. Check that the proposed language or framework can
   actually deliver the promised error at the stated boundary; leave unresolved
   policy explicit rather than assigning an accidental runtime behavior.
   When an authoritative scope decision changes an existing proposal, apply it
   throughout the artifact. Reconcile the goal, scope, constraints, file map,
   review focus, tasks, dependencies, risks, acceptance checklist, verification,
   and handoff; remove stale work and checks. Keep a brief decision note only
   when future readers need to know why scope changed. Before delivery, search
   for names and terms from the removed scope and resolve every remaining
   reference, including references that imply the work is still required.

## Output and completion

Save the plan as Markdown at `.panda-suite/plans/YYYY-MM-DD-<topic>.md`, using
the current local date and a short lowercase hyphenated topic. Create the directory
when needed. An explicit user-requested destination takes precedence. Avoid
overwriting an unrelated existing plan; choose a distinct descriptive filename.
When the user requests an answer only in chat, honor that format. If the workspace
cannot be written, provide the plan in the response and explain the limitation.

When saving a plan inside `.panda-suite` in a Git repository, ensure the
repository root `.gitignore` ignores `/.panda-suite/`. Create the file if needed,
preserve existing entries, and avoid adding a duplicate when an existing rule
already covers the directory. Verify the intended plan path with `git check-ignore`.
Ignore rules do not remove files already tracked by Git; report any tracked
`.panda-suite` files and leave the index unchanged. If the ignore rule cannot be
updated or verified, report that limitation. Respect an explicit request to track
the plan or a repository instruction requiring it.

Start the document with a title, goal, scope, relevant source or specification,
and constraints; copy project-wide constraints with exact values from the source
requirement. Add a review focus: up to five inputs or failure modes the
requirements imply but no task yet tests, most likely first, each with the
behavior a reasonable user expects, and add its test to the owning task. Say
when the check found none. Map the affected files and responsibilities before the tasks.
Include evidence anchors, ordered tasks, dependencies, risks, decisions, and a
verification strategy. Use Markdown checkboxes for actionable steps. Each task
names its objective, affected files or components, prerequisites, acceptance
criteria, and concrete checks. Specify interfaces and expected check results
where they matter. Scale detail to the work and mark unknown paths or commands
as provisional. A task can use this format:

> Add manager rejection in `service.py`; depends on the agreed terminal-state
> contract. Accept when only managers can reject pending requests and a blank
> reason is rejected. Verify with focused permission/status/reason tests and the
> existing approval suite. Persistence is outside the supplied service's scope.

Before delivery, check that each requirement maps to a task, task interfaces
agree, material risks have checks or decisions, proposed verification can
detect the relevant failures, and no step is a placeholder or a code transcript. Link the saved plan in the response and identify
any unresolved decisions or checks. Saving a plan does not require a commit.

## Execution handoff

When a plan is saved and implementation is a relevant next step, ask the user to
review the plan and, unless they already chose, how `panda-execute` should run it:

- **Subagent-driven:** a fresh agent implements each task and a fresh reviewer
  checks it before the next starts, then one whole-change review. Most thorough;
  costs a fresh context per task and review. Offer only when the host can delegate.
- **Native:** this session implements every task, then one review of the whole
  change (by a fresh reviewer when the host can delegate). Cheapest and fastest;
  no independent review until the end.

Recommend one in a sentence grounded in the plan: how many tasks, how much they
depend on each other's interfaces, and what a shipped mistake would cost. Give a
ready-to-use request such as “Use panda-execute (native) to implement
`.panda-suite/plans/<filename>.md`.” When the user already named a mode, keep it
and ask only for the review. When the user asked for a chat-only answer or no
execution, mention the handoff without the menu. Wait for the user's answer:
saving a plan, or choosing a mode in advance, does not by itself authorize
starting implementation unless the user's request already did.

Do not estimate duration without evidence. Planning authorizes the requested plan
artifact, not application implementation. Do not edit source or tests. Do not
require Panda Lead. A handoff to execution preserves acceptance criteria, current
artifacts, decisions, unknowns, and the user's actual authorization; a generated
plan alone is not approval to execute it.

## Success discipline

Identify the requested outcome and evidence of completion. Continue useful authorized work, keep attention on current evidence, and compare the result with the outcome before reporting completion. State any remaining uncertainty or blocker. Vīmaṃsā: Before finishing, map each acceptance condition to a task and a check.

Wersje

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

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

  • 85pandacss-optimizer
    Audytuje użycie Panda CSS w projekcie, mierzy koszt generowanego CSS i przygotowuje plan poprawek do zatwierdzenia przed zmianami w kodzie.
  • 100writing-plans
    Tworzy szczegółowy plan wdrożenia na podstawie specyfikacji, dokumentu projektowego lub wymagań, z kolejnością implementacji, przed rozpoczęciem kodowania.
  • 100panda-craft
    Łączy wybrane skille Agent Skills w jeden cel, koordynuje przekazania i weryfikuje odbiór, gdy użytkownik o to prosi.
  • 100planning-and-task-breakdown
    Rozkłada specyfikacje na małe, uporządkowane zadania z kryteriami akceptacji i krokami weryfikacji, tworząc plan implementacji lub listę zadań.
  • 100fai-implementation-plan-generator
    Generuje krokowe plany implementacji z architektury lub projektu: podział pracy, kolejność, zależności i kryteria akceptacji, do planowania sprintu lub zakresu budowy.
  • 100dev-plan
    Tworzy konkretne plany implementacji po poznaniu wymagań: kroki na poziomie plików, kolejność, strategię testów, ryzyka i weryfikację przed kodowaniem funkcji, poprawki, refaktoryzacji lub migracji.

Uwagi i zgłoszenia

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