Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

research-plan-implement

/research-plan-implement

Prowadzi trzyfazowy workflow RPI (research, plan, implementacja) dla nietrywialnych zmian w kodzie.

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

Brak sygnałów. Repozytorium zmienione 10.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 trzyfazowy workflow RPI (research, plan, implementacja) dla nietrywialnych zmian w kodzie.

Oryginalny opis (EN)

Three-phase RPI workflow (Research, Plan, Implement). Use for non-trivial code changes.

Jak działa

  1. When to Use
  2. When NOT to Use
  3. Workflow
  4. Phase 1: Research
  5. Phase 2: Plan
  6. Phase 3: Implement
  7. Intent Compression
  8. Sub-Agent Strategy
  9. Escalation
Sekcje z nagłówków SKILL.md, w oryginale · 222 linii, 1 134 słów
Podgląd SKILL.md
---
name: research-plan-implement
description: Three-phase RPI workflow (Research, Plan, Implement). Use for non-trivial code changes.
---

# Research-Plan-Implement (RPI)

A disciplined three-phase workflow that trades speed for clarity, predictability, and correctness. Each phase has a validation gate that must pass before proceeding.

**Core principle**: Never let AI write code without first researching the codebase and producing a validated plan. A 1-page plan gives 10x leverage over reviewing 1,000 lines of AI code.

## When to Use

- Non-trivial features, refactors, or bug fixes
- Unfamiliar or large codebases
- Tasks where incorrect code is costlier than slow code
- When previous direct-implementation attempts have failed

## When NOT to Use

- Single-line fixes, typos, or trivial changes
- Tasks where you already have full context and a clear path
- Exploratory prototyping (use RPI when hardening the prototype)

## Workflow

Copy this checklist and track progress:

```
- [ ] Phase 1: Research (FAR validated)
- [ ] Phase 2: Plan (FACTS validated)
- [ ] Phase 3: Implement (verified)
```

---

## Phase 1: Research

**Goal**: Explore the codebase, find the right files. Make ZERO modifications.

Use sub-agents (Task tool with `Explore` type) to read broadly without polluting the main context. Sub-agents return only compressed facts.

### Research Outputs

For each finding, record:
- **File path** and **line number(s)**
- **What** exists there (function signature, data structure, pattern)
- **Why** it matters to the current task

### FAR Validation Gate

Every finding must pass all three:

| Check | Question | Fail Example |
|-------|----------|-------------|
| **F**actual | Is this from actual code, not assumption? | "There's probably a config file somewhere" |
| **A**ctionable | Does it include specific file path + line number? | "The auth module handles this" |
| **R**elevant | Is it directly related to the task? | Documenting unrelated utility functions |

**Template for research summary**:

```markdown
## Research Findings for: {task description}

### Finding 1: {short title}
- **File**: `src/auth/middleware.ts:42-67`
- **What**: `validateToken()` checks JWT expiry and role claims
- **Why**: We need to extend this to support API key auth

### Finding 2: {short title}
- **File**: `src/types/auth.ts:15-23`
- **What**: `AuthContext` interface defines `user`, `token`, `roles`
- **Why**: Must add `apiKey` field here

### FAR Check
- [x] All findings reference actual code with paths and line numbers
- [x] No assumptions or guesses included
- [x] Every finding directly relates to the task
```

**Do NOT proceed to Phase 2 until FAR passes.**

---

## Phase 2: Plan

**Goal**: Produce a step-by-step plan where each step has code-level specificity.

A plan without code snippets is just a "feeling" -- it has no execution power.

### Plan Structure

For each step:

```markdown
### Step N: {action verb} + {what}

**File**: `path/to/file.ts:line-range`
**Change**: {precise description of what to add/modify/remove}
**Code sketch**:
  ```typescript
  // Before (current):
  function validateToken(token: string): AuthContext { ... }

  // After (planned):
  function validateAuth(credential: string | ApiKey): AuthContext { ... }
  ```
**Verify**: {how to confirm this step succeeded}
**Scope**: Changes ONLY `validateToken` signature and body. Does NOT touch callers yet.
```

### FACTS Validation Gate

Every step must pass all five:

| Check | Question | Fail Example |
|-------|----------|-------------|
| **F**easible | Can this be done in the current environment? | "Migrate to a new framework" mid-task |
| **A**tomic | Does it do exactly one thing? | "Update auth and refactor tests" |
| **C**lear | Are file names, line numbers, and code snippets present? | "Update the relevant files" |
| **T**estable | Is there a concrete verification step? | "Make sure it works" |
| **S**coped | Is it clear what changes and what doesn't? | No mention of boundaries |

**FACTS checklist**:

```markdown
### FACTS Validation
- [ ] F: Every step is achievable in current environment
- [ ] A: Each step has exactly one objective
- [ ] C: Every step has file path, line numbers, and code sketch
- [ ] T: Every step has a specific verification command or check
- [ ] S: Every step states what it changes AND what it leaves untouched
```

**Do NOT proceed to Phase 3 until FACTS passes.**

### Present Plan to User

After FACTS validation, present the plan for human review. The plan is the primary review artifact -- it's far more efficient to review a plan than to review generated code.

---

## Phase 3: Implement

**Goal**: Execute the validated plan with minimal context pressure.

### Execution Rules

1. **Follow the plan step by step** -- do not improvise or "improve" beyond scope
2. **One step at a time** -- complete and verify each step before the next
3. **Use sub-agents for independent steps** -- keep main context lean
4. **Verify after each step** -- run the verification defined in the plan

### After Each Step

```markdown
Step N: {title}
- Status: DONE / BLOCKED / MODIFIED
- Verification: {result of the verification step}
- Deviation: {none, or explain why plan was adjusted}
```

### If a Step Fails

1. **Do NOT retry blindly** -- diagnose why it failed
2. **Update the plan** with new information
3. **Re-validate FACTS** on the updated step
4. If 3+ steps fail consecutively, **STOP** -- see Escalation below

---

## Intent Compression

When the conversation becomes long or starts going off track (roughly 20+ turns):

1. **Stop all implementation work**
2. **Summarize** key research findings and plan state into a compressed format:

```markdown
## Compressed Context for: {task}

### Validated Facts
- {fact 1 with file path and line number}
- {fact 2 with file path and line number}

### Plan Status
- Steps completed: {list}
- Current step: {N} - {status}
- Remaining: {list}

### Blockers
- {any unresolved issues}
```

3. **Start a new conversation** with this compressed context

Better input produces better output. A fresh context with compressed facts outperforms a bloated context with noise.

---

## Sub-Agent Strategy

Sub-agents are sharding tools, not personas. Use them to:

| Task | Agent Type | Returns |
|------|-----------|---------|
| Broad codebase reading | `Explore` | Compressed file/function map |
| Targeted search | `Explore` | Specific paths and line numbers |
| Independent implementation steps | `Bash` or `general-purpose` | Step completion status |
| Test execution | `Bash` | Pass/fail with output |

**Rules**:
- Sub-agents do the heavy reading; main agent does the reasoning
- Sub-agents return compressed facts, not raw file contents
- Never let main context absorb entire files when a sub-agent can extract the relevant lines

---

## Escalation

When RPI plans repeatedly fail (3+ consecutive step failures), this signals that the task complexity exceeds what AI can handle with current context.

**Action**: Stop. Return to the whiteboard. The human must re-think the approach and break the problem down differently before re-engaging AI.

Do not brute-force through repeated failures -- that wastes context and produces bad code.

Wersje

RepozytoriumWynikLicencja
Ta strona · htlin222/dotfiles100MIT
RaditteAnggoro/skill-for-lazy-developer100MIT
RaditteAnggoro/agent-doctor-for-your-devices85MIT

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

  • 90rpi-implement
    Wykonuje zatwierdzony plan z katalogu .rpi/plans fazami, w podejściu TDD i z weryfikacją po każdej fazie.
  • 90rpi-implement
    Wykonuje zatwierdzony plan z katalogu .rpi/plans fazami, w podejściu TDD i z weryfikacją po każdej fazie.
  • 100rpi
    Koordynuje wznawialną sesję RPI przez fazy: badanie, planowanie, wdrożenie, przegląd i kontynuację, z trwałym stanem.
  • 90rpi-implement
    Realizuje zatwierdzony plan RPI, aktualizuje go przy nowych informacjach, odhacza ukończone prace i prowadzi skrócony dziennik zmian.
  • 100rpi
    Prowadzi jedną zaakceptowaną zmianę przez implementację i kontrole do ukończenia, z jednym świeżym przeglądem tam, gdzie pomyłka kosztuje najwięcej.
  • 90plan-feature
    Wymusza najpierw zrozumienie kodu i jawny plan przed edycją, przy zmianach nietrywialnych, takich jak funkcje i refaktoryzacje.

Uwagi i zgłoszenia

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