Przejdź do treści
Biblioteka skilli
Programowanie · Przegląd i audyt

receiving-code-review

/receiving-code-review

Obsługuje poprawki po werdykcie REWORK superpowers-evaluator i uwagi z code review do pracy superpowers, wymagając technicznej weryfikacji przed wdrożeniem.

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

Obsługuje poprawki po werdykcie REWORK superpowers-evaluator i uwagi z code review do pracy superpowers, wymagając technicznej weryfikacji przed wdrożeniem.

Oryginalny opis (EN)

Use when the superpowers-evaluator returned REWORK on a batch, when fixing rework items from an evaluation report, or when receiving any code review feedback on superpowers output. Requires technical rigor and verification instead of performative agreement or blind implementation.

Jak działa

  1. The Response Pattern
  2. Forbidden Responses
  3. Handling Unclear Items
  4. When To Push Back
  5. Implementation Order for Multi-Item REWORK
  6. The Bottom Line
Sekcje z nagłówków SKILL.md, w oryginale · 76 linii, 598 słów
Podgląd SKILL.md
---
name: receiving-code-review
description: Use when the superpowers-evaluator returned REWORK on a batch, when fixing rework items from an evaluation report, or when receiving any code review feedback on superpowers output. Requires technical rigor and verification instead of performative agreement or blind implementation.
user-invocable: false
---

# Receiving Code Review (the evaluator REWORK loop)

The superpowers-evaluator returns REWORK with file:line evidence. Your job is to fix the right thing — not to please the evaluator.

**Core principle:** Verify before implementing. Ask before assuming. Technical correctness over social comfort. The evaluator is a red-team reviewer, not an order-giver.

## The Response Pattern

Run this for each rework item before changing code:

1. **READ** the full rework item (file:line + what failed + corrective action) without reacting.
2. **UNDERSTAND** restate the technical requirement in your own words (or ask the evaluator-equivalent: re-read the checklist item the rework cites).
3. **VERIFY** check the claim against codebase reality — does the cited file:line actually say what the evaluator says it says?
4. **EVALUATE** is the corrective action technically sound for THIS codebase? (see Push Back below)
5. **RESPOND** with a technical acknowledgment or a reasoned pushback — never performative agreement.
6. **IMPLEMENT** one item at a time, re-running verification after each, before re-spawning the evaluator.

## Forbidden Responses

**NEVER output, even when the evaluator is right:**
- "You're absolutely right!" / "Great point!" / "Excellent feedback!" / "Thanks for catching that"
- "Let me implement that now" before verification
- Any gratitude expression or performative agreement

**INSTEAD:**
- Restate the technical requirement
- Ask a clarifying question if the item is unclear
- Push back with technical reasoning if wrong
- Just fix it and show the diff — actions speak, the code shows you heard it

## Handling Unclear Items

If ANY rework item is unclear, do NOT implement the clear ones and defer the unclear ones. Items may be related — partial understanding produces wrong implementation.

```
Evaluator: 4 rework items. You understand items 1,2,4. Unclear on item 3.

WRONG:  implement 1,2,4 now, ask about 3 later
RIGHT:  re-read the cited checklist item for 3; if still unclear, note the
        ambiguity in your return and implement 1,2,4 only after 3 is resolved
        (or explicitly mark 3 as [AUTO-RESOLVED] per the sprint contract's
        Autonomous Resolution Protocol with the most concrete interpretation)
```

## When To Push Back

Push back (with technical reasoning, not defensiveness) when a rework item:
- Breaks existing functionality the evaluator didn't see
- Cites a checklist item that doesn't apply to this batch's scope
- Violates YAGNI (the "fix" adds a feature nothing uses)
- Is technically incorrect for this stack
- Conflicts with a prior architectural decision recorded in the plan's `## Global Constraints` block
- The evaluator misread the file (file:line doesn't say what the report claims)

**How to push back in your return:**
- Reference working tests / specific file:line that contradicts the finding
- State what you verified and what you couldn't
- If architectural, flag for the main agent's PIVOT consideration

If the evaluator was right and you were wrong: state the correction factually and move on. No long apology, no defending why you pushed back.

## Implementation Order for Multi-Item REWORK

1. Clarify all unclear items FIRST (re-read checklist items)
2. Then implement in this order:
   - Blocking issues (breaks tests, security, correctness)
   - Simple fixes (typos, imports, missing guards)
   - Complex fixes (refactoring, logic changes)
3. Re-run the task's verification command after EACH fix (per `verification-before-completion`)
4. Re-spawn the superpowers-evaluator for the next round only after all items are addressed and verification passes THIS TURN.

## The Bottom Line

Evaluator REWORK = findings to evaluate, not orders to follow. Verify each item against the codebase. Question the wrong ones. Implement the right ones one at a time with verification. No performative agreement, no blind batch implementation.

Wersje

RepozytoriumWynikLicencja
Ta strona · FradSer/dotclaude100MIT
event4u-app/agent-config100MIT
drvoss/everything-copilot-cli100MIT
rootcastleco/rei-skills100MIT
foryourhealth111-pixel/Vibe-Skills100Apache-2.0
jjuraszek/pi-gauntlet100MIT
coco-research/coco100MIT
davila7/claude-code-templates100MIT
osmontero/opencode-skills100MIT

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

  • 100receiving-review
    Weryfikuje każdą uwagę z przeglądu kodu przed wdrożeniem, z rzetelnością techniczną i bez automatycznego potakiwania.
  • 100receiving-code-review-codex
    Weryfikuje uwagi z code review w Codex przed wdrożeniem, z technicznym uzasadnieniem każdej decyzji i bez ślepego wykonywania sugestii.
  • 100ferrox-receiving-code-review
    Pomaga rzetelnie przyjmować uwagi z code review: weryfikuje je technicznie przed wdrożeniem, także gdy są niejasne lub wątpliwe.
  • 100sr-receiving-code-review
    Pomaga przyjmować uwagi z code review rzetelnie i z weryfikacją, zanim wdroży się sugestie, zwłaszcza wątpliwe technicznie.
  • 100implementer-receiving-review-feedback
    Ustala zasady odpowiadania na zgłoszone przez recenzenta uwagi w trakcie cyklu przeglądu, jako uzupełnienie superpowers:receiving-code-review.
  • 100receiving-orders
    Przetwarza uwagi z code review rzeczowo: każde polecenie sprawdza technicznie, zanim je wykona.

Uwagi i zgłoszenia

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