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

forge-shape

/forge-shape

Przekształca niejasny pomysł w konkretny plan przez badanie bazy kodu i pytania zadawane po jednym, zanim powstanie zgłoszenie.

Repozytorium
forge ↗
Licencja
MIT
Ostatnia zmiana repozytorium
25.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 25.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

Przekształca niejasny pomysł w konkretny plan przez badanie bazy kodu i pytania zadawane po jednym, zanim powstanie zgłoszenie.

Oryginalny opis (EN)

Shape a vague idea into a clear plan through codebase investigation and convergent one-at-a-time questioning. Use when the user has a rough idea or problem that needs specifying before issue creation.

Jak działa

  1. Input
  2. Process
  3. Output Format
  4. Guidelines
  5. Related Skills
  6. Example Usage
Sekcje z nagłówków SKILL.md, w oryginale · 119 linii, 834 słów
Podgląd SKILL.md
---
name: forge-shape
description: Shape a vague idea into a clear plan through codebase investigation and convergent one-at-a-time questioning. Use when the user has a rough idea or problem that needs specifying before issue creation.
disable-model-invocation: true
allowed-tools: Read, Edit, Write, Bash, Grep, Glob, WebSearch, AskUserQuestion
---

# Shape a Problem

Shape a problem and converge on a plan before creating issues.

## Input

The idea or problem to shape: $ARGUMENTS

Optional: `-- <additional context>` for execution guidance.

If no argument is provided, ask the user what they'd like to shape.

## Process

### Step 1: Investigate Context

Before asking any questions, explore the codebase for related context:
- Find existing implementations, patterns, and constraints relevant to the idea
- Identify integration points, dependencies, and architectural boundaries
- Look for prior attempts or related work (git log, closed issues)

Check for related Issues in the project's Issue tracker — see [issue-operations](_shared/issue-operations.md) for search mechanics per provider.

### Step 2: Shape the Problem

Converge on a shared design concept through one-at-a-time structured questioning. See [shaping-methodology.md](references/shaping-methodology.md) for why one-at-a-time beats batching, how to provide recommended answers without over-anchoring, walking the dependency tree of decisions, when to challenge, and when to stop.

If CONTEXT.md exists, read it — use its vocabulary when framing questions and challenging the user's language.

Ground each question in Step 1 facts, so you never ask what the codebase already answers, and give your recommended answer as "I'd suggest X because Y", not as a decision. **Challenge when warranted:** if an answer conflicts with CONTEXT.md vocabulary, call it out; if it contradicts what the code does, surface it; if it uses vague or overloaded terms, propose a precise canonical term; invent concrete scenarios to stress-test fuzzy boundaries.

**Side effects during shaping** — as terms and decisions crystallize:
- **Resolved term?** Update CONTEXT.md inline — don't batch. Add the term with a tight definition and `_Avoid_` aliases if the user was using multiple words for the same concept.
- **Load-bearing decision?** If it's hard to reverse, surprising without context, and the result of a real trade-off — offer to record it as a short ADR in `docs/adr/`. Most decisions don't qualify. Create the directory lazily.

Stop when the user has accepted recommended answers for several consecutive questions, the remaining questions are taste-level (not decision-level), or the shared design concept is clear enough to summarize.

**Use AskUserQuestion** for each individual question. Do not bundle multiple questions into one prompt — that defeats the methodology.

### Step 3: Explore Approaches (delegate)

**This step is optional.**

If shaping in Step 2 surfaced a clear approach, skip this step and go to Step 4.

If multiple plausible approaches remain after shaping (e.g., the design concept allows for several architectural shapes), delegate approach generation to 2-3 parallel sub-agents, each given a radically different design constraint. The value is in **contrast** — approaches must be structurally different, not variations on the same idea. If the runtime does not support sub-agents, generate the approaches sequentially yourself, deliberately adopting a different constraint lens for each.

Assign each sub-agent one constraint lens (adapt to the problem):
- **Minimal** — smallest change that addresses the core problem
- **Reuse-first** — maximize use of existing patterns and code
- **Extensibility-first** — optimize for future flexibility
- **Performance-first** — optimize for speed or resource efficiency

**Sub-agent instructions:**

> You are designing one approach to a problem, constrained by a specific design lens. Follow your assigned constraint strictly — do not hedge toward a balanced middle ground.
>
> Given the codebase findings and shaped design concept provided as input, propose one approach:
> - One-line summary
> - How it works, referencing specific files and patterns
> - Tradeoffs (what you gain, what you give up)
> - Relative complexity (Low / Medium / High)
> - Risk factors

**Inputs provided to each sub-agent:**
- Codebase facts from Step 1
- Shaped design concept from Step 2
- The specific constraint lens to apply

**Expected output:** One approach per sub-agent, formatted as above.

Always include a **minimal option**. Present the contrasting approaches and let the user choose, combine, or reject all of them.

### Step 4: Summarize Plan

Produce a structured summary using the output format below. This summary is the input for `forge-create-issue`.

The summary is *evidence* of alignment, not the alignment itself. If the user reads the summary and finds nothing surprising, the shaping worked.

## Output Format

```markdown
## Problem Statement
[1-2 sentences grounded in what was discussed]

## Chosen Approach
[Summary of the shaped design concept]

## Scope Boundaries
- In scope: [what this covers]
- Out of scope: [what this explicitly does not cover]

## Suggested Issue Breakdown
- [ ] Issue 1: <type>(<scope>): <description>
- [ ] Issue 2: <type>(<scope>): <description>

## Side Effects
- CONTEXT.md: <terms added or updated>
- ADRs: <decisions recorded, if any>
```

## Guidelines

- **Problem over solution** — clarify what's wrong before proposing how to fix it
- **Stay grounded** — reference specific code, files, and patterns, not abstractions

## Related Skills

**Next step:** Use `forge-create-issue` to turn the plan into Issues.

## Example Usage

```
/forge-shape the app is slow on mobile
/forge-shape we need better error handling
/forge-shape the authentication flow -- we've had security concerns, focus there
```
Pliki w paczce (3)
  • SKILL.md 6 KB
  • _shared 1 KB
  • references/shaping-methodology.md 2 KB

Wersje

W bazie nie ma innych skilli o nazwie forge-shape.

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

  • 100brainstorm-beagle
    Przekształca niejasny pomysł w konkretną specyfikację projektu, zadając pytania o zakres, bez pisania kodu ani planu wdrożenia.
  • 100forge-create-issue
    Współtworzy dobrze ustrukturyzowane zgłoszenia przez interaktywną rozmowę (GitHub, folder plan w markdown lub inni dostawcy), gdy trzeba opisać błąd lub zakres już zrozumianej pracy.
  • 100v1-interview-me
    Zadaje uporządkowane pytania o pomysł lub zgłoszenie, zanim zespół zacznie planowanie i specyfikację.
  • 100shape
    Zamienia surowy pomysł w plan przed budową: wywiad w rundach, zakres, stos i krótki dokument projektu do zatwierdzenia.
  • 90grill-me
    Zadaje jedno pytanie naraz, by doprecyzować niejasny pomysł lub plan, zanim zacznie się pisanie kodu.
  • 100bmad-forge-idea
    Testuje niedojrzały pomysł w rozmowie pytań, z różnymi personami szukającymi słabych punktów, aż da się go ocenić lub porzucić.

Uwagi i zgłoszenia

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