Przejdź do treści
Biblioteka skilli
AI i agenci · Planowanie

background-planner

/background-planner

Prowadzi równoległe planowanie z niezależnymi personami plannerów i opcjonalnymi workerami wielu LLM, a potem łączy wyniki w jeden plan z listą konfliktów i otwartych pytań.

Repozytorium
agent-skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
01.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
3
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 01.10.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

Prowadzi równoległe planowanie z niezależnymi personami plannerów i opcjonalnymi workerami wielu LLM, a potem łączy wyniki w jeden plan z listą konfliktów i otwartych pytań.

Wyzwalacze z opisu

백그라운드 기획bg plan병렬 기획멀티 AI 기획N명이 기획
Oryginalny opis (EN)

Run bounded parallel planning with independent planner personas and optional multi-LLM workers, then synthesize a single plan via stance-steered consensus with explicit conflicts and open questions. Use only when the user explicitly requests background, parallel, or multi-agent planning, such as "백그라운드 기획", "bg plan", "병렬 기획", "멀티 AI 기획", or "N명이 기획". Do not trigger for ordinary planning or design requests.

Jak działa

  1. 1. Frame the problem
  2. 2. Assign planner perspectives
  3. 3. Plan schema
  4. 4. Synthesize by stance, not by average
  5. 5. Iterate (optional)
  6. Best practices
  7. Version Notes
Sekcje z nagłówków SKILL.md, w oryginale · 107 linii, 620 słów
Podgląd SKILL.md
---
name: background-planner
description: Run bounded parallel planning with independent planner personas and optional multi-LLM workers, then synthesize a single plan via stance-steered consensus with explicit conflicts and open questions. Use only when the user explicitly requests background, parallel, or multi-agent planning, such as "백그라운드 기획", "bg plan", "병렬 기획", "멀티 AI 기획", or "N명이 기획". Do not trigger for ordinary planning or design requests.
trigger-keywords: [bg plan, 백그라운드 기획, 병렬 기획, 멀티 AI 기획, parallel planning, N명이 기획]
tags: [planning, parallel, multi-agent, persona]
---

# Background Planner

Produce independent planning perspectives in parallel, then synthesize one plan that
names its trade-offs and open questions instead of averaging them away.

Mechanics (worker invocation, provider recipes, `.context/` layout, persona modes, token
discipline) live in `references/orchestration.md`. This file owns the workflow, the
schema, and the synthesis rules.

## 1. Frame the problem

Before delegating, pin down one planning target:

- the goal and the definition of done
- hard constraints (deadline, stack, compatibility, data, budget)
- what is explicitly out of scope

Persist to `.context/plans/` only when useful (repeated rounds, cross-tool workers, or a
requested document). Use rounds `R01`, `R02`, … (see orchestration reference).

## 2. Assign planner perspectives

Run **2–4** independent planners, each with a distinct lens — do not send them each
other's drafts. Draw lenses from the planning personas in `personas/*.md`:

| Lens | Persona | Owns |
|------|---------|------|
| technical / decomposition | `technical-planner` | architecture, sequencing, dependencies, unknowns |
| product / scope | `product-planner` | user value, MVP cut, prioritization, success metrics |
| delivery / risk | `delivery-risk-planner` | failure modes, rollout, migration, reversibility |

Add a domain reviewer persona as a planning lens when the work is domain-heavy (e.g.
`security-reviewer` for an auth redesign, `database-reviewer` for a schema change).

For diverse-model planning, run the same lens on a different provider (Claude / Codex /
Gemini) per the orchestration reference — but keep total workers at 2–4.

## 3. Plan schema

Each planner returns this shape so synthesis is deterministic, not prose-matching:

```yaml
approach: one-line thesis of this plan
steps:
  - id: S1
    do: concrete action
    depends_on: []           # step ids this blocks on
    effort: S | M | L
    risk: low | med | high
assumptions: [things taken as given]
risks: [what could go wrong + mitigation]
open_questions: [decisions this plan cannot make alone]
success_criteria: [how "done" is verified]
```

## 4. Synthesize by stance, not by average

Wait for every planner, then build `R0N-merged.md`. Do not blend plans into mush:

- **Agreements** — steps/assumptions all planners share → high-confidence backbone.
- **Conflicts** — where plans diverge, present each side's case *for* and *against*
  (stance-steered), then recommend one with a reason. Surface the trade-off; do not hide it.
- **Dependency order** — merge steps into one DAG; flag ordering the individual plans got
  wrong.
- **Open questions** — union of everything no plan could decide; these gate execution.

```markdown
# Plan Synthesis (R01)

## Recommended approach
## Steps (dependency-ordered)
| id | do | depends_on | effort | risk |
## Agreements
## Conflicts & trade-offs
| topic | option A (for/against) | option B (for/against) | recommendation |
## Assumptions
## Open questions (must resolve before build)
## Success criteria
```

## 5. Iterate (optional)

If the user gives feedback or answers open questions, run `R02` — re-plan only the
affected parts, keep resolved decisions fixed. Stop when the plan is executable (no
blocking open questions), when feedback stops changing the plan, or at the user's bound.

## Best practices

**Do**
- Use 2–4 planners for genuinely different perspectives.
- Let each planner return the schema; keep raw drafts in `.context/plans/`.
- Name conflicts and open questions explicitly — an honest plan beats a confident one.

**Don't**
- Tight-poll for completion (token waste; results arrive by notification).
- Run 5+ planners (diminishing returns at ~15× single-agent cost).
- Synthesize before all bounded planners finish, unless the user asked for fire-and-forget.
- Average conflicting plans into a vague middle.

## Version Notes

- Worker/provider recipes verified on 2026-07-23; re-check `--help` before trusting a
  flag. See `references/orchestration.md`.
- Planner lenses come from the planning personas in `personas/*.md` — keep those as the
  source of truth rather than inlining lenses here.
Pliki w paczce (3)
  • SKILL.md 5 KB
  • agents/openai.yaml 1 KB
  • references/orchestration.md 6 KB

Wersje

W bazie nie ma innych skilli o nazwie background-planner.

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

  • 100background-implementer
    Prowadzi ograniczoną równoległą implementację z izolowanymi workerami (natywne worktree lub Codex), z grafem zależności i weryfikacją diffu każdego workera przed integracją, wyłącznie na wyraźną prośbę.
  • 100planner
    Prowadzi dwusesyjny przepływ planowania zmian w repozytorium i przekazuje zatwierdzone wdrożenie innemu modelowi przez plik PLANNER.md.
  • 100delegate-work
    Koordynuje równoległe subagenty, dzieli pracę, izoluje kontekst i unika konfliktów w plikach, a potem sprawdza wyniki.
  • 100multi-agent-workforce-planner
    Projektuje równoległe ścieżki pracy agentów dla dużych zestawów funkcji: analiza zależności, przydział typów agentów, maksymalizacja równoległości oraz plan wykonania ze śledzeniem postępu i odzyskiwaniem po awariach.
  • 100orchestrating-subagents
    Prowadzi równoległe i szeregowe subagenty: koordynuje wykonanie planu z wielu jednostek, syntetyzuje wyniki niezależnych przebiegów i obsługuje awarie z ponowieniem.
  • 100workflow-orchestration
    Koordynuje ustrukturyzowane myślenie i równoległe wykonanie przez wielu agentów przy złożonych zadaniach: planowanie pracy równoległej, rozbijanie problemów, koordynacja specjalistów i decyzje architektoniczne.

Uwagi i zgłoszenia

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