Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

loop-executor

/loop-executor

Realizuje zadania ze zweryfikowanego planu w kroku 3 pętli Evaluate-Loop: przechodzi po kolei przez plan.md, pisze kod, aktualizuje plan po każdym zadaniu i commituje w punktach kontrolnych, stosując TDD.

Licencja
AGPL-3.0
Ostatnia zmiana repozytorium
27.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
1
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 27.09.2026, bez odwołań do wycofanych modeli i API.

Licencja

AGPL-3.0, copyleft: przeróbki udostępniane innym muszą mieć tę samą licencję.

Co sprawdzić przed instalacją
  • SKILL.md zawiera komentarze HTML (1). Nie widać ich w podglądzie Markdown, a model je czyta.

Co robi i kiedy

Realizuje zadania ze zweryfikowanego planu w kroku 3 pętli Evaluate-Loop: przechodzi po kolei przez plan.md, pisze kod, aktualizuje plan po każdym zadaniu i commituje w punktach kontrolnych, stosując TDD.

Wyzwalacze z opisu

execute planimplement trackbuild feature
Oryginalny opis (EN)

Evaluate-Loop Step 3: EXECUTE. Use this agent to implement tasks from a verified plan. Works through plan.md tasks sequentially, writes code, updates plan.md after every task, and commits at checkpoints. Uses TDD where applicable. Triggered by: 'execute plan', 'implement track', 'build feature', '/conductor implement' (execution phase). Only runs after plan has passed evaluation.

Jak działa

  1. Pre-Execution Checklist
  2. Execution Protocol
  3. Execution Summary
  4. Metadata Checkpoint Updates
  5. Handoff
Sekcje z nagłówków SKILL.md, w oryginale · 212 linii, 746 słów
Podgląd SKILL.md
---
name: loop-executor
description: "Evaluate-Loop Step 3: EXECUTE. Use this agent to implement tasks from a verified plan. Works through plan.md tasks sequentially, writes code, updates plan.md after every task, and commits at checkpoints. Uses TDD where applicable. Triggered by: 'execute plan', 'implement track', 'build feature', '/conductor implement' (execution phase). Only runs after plan has passed evaluation."
---

# Loop Executor Agent — Step 3: EXECUTE

Implements the tasks defined in a verified `plan.md`. This agent writes code, creates files, and updates plan.md after every completed task.

## Pre-Execution Checklist

Before writing any code:

1. read_file `plan.md` — find first `[ ]` task (skip all `[x]` tasks)
2. Confirm plan was evaluated (check for Plan Evaluation Report in plan or track metadata)
3. If no evaluation found → STOP → request Conductor run loop-plan-evaluator first

## Execution Protocol

### For Each Task

```
1. Mark task [~] in plan.md (in progress)
2. read_file acceptance criteria
3. Implement the task
4. Verify acceptance criteria met
5. Update plan.md immediately:
   - Mark [x]
   - Add commit SHA
   - Add summary of what was done
6. Commit code changes
7. Move to next [ ] task
```

### plan.md Update Format (MANDATORY after every task)

```markdown
- [x] Task 3: Build signup form component <!-- abc1234 -->
  - Created src/components/auth/signup-form.tsx
  - Added email validation (regex), password min 8 chars
  - Integrated with authApi.signUp() from mock API client
  - Acceptance: ✅ Form renders, validates, submits
```

### TDD Integration

For tasks involving business logic, follow TDD from the `tdd-implementation` skill:

```
RED   → write_file failing test for the task's acceptance criteria
GREEN → write_file minimal code to pass
REFACTOR → Clean up while tests stay green
```

Apply TDD to:
- Dependency resolution logic
- Lock/unlock/outdated propagation
- Price calculations and tier enforcement
- API request/response handling
- Form validation logic

Skip TDD for:
- CSS/styling tasks
- Static content
- Third-party library wrappers

### Commit Protocol

Commit at these checkpoints:
- After each completed task (with plan.md update in same commit)
- After each completed phase
- Message format: `feat([scope]): [what was done]`

### Scope Discipline During Execution

While executing, if you discover work not in the plan:

```markdown
## Discovered Work
- [ ] [Description of discovered work]
  - Reason: [Why this is needed]
  - Recommendation: [Add to current track / Create new track]
```

Add to `plan.md` under "Discovered Work" section. Do NOT silently implement it.

### Business Doc Sync Awareness

While executing, if a task makes any of these changes, flag it for Step 5.5 (Business Doc Sync):
- Pricing tier, price point, or feature list changes
- AI model, SDK, or cost structure changes
- New package or tier additions
- Persona, GTM, or revenue assumption changes
- Asset pipeline changes (add/remove/modify assets)

Add a note in the execution summary:

```markdown
**Business Doc Sync Required**: Yes/No
**Reason**: [e.g., "Added premium tier with Pro model"]
**Affected Docs**: [list from business-docs-sync skill registry]
```

See `${CLAUDE_PLUGIN_ROOT}/skills/business-docs-sync/SKILL.md` for the full sync registry and protocol.

### Error Handling During Execution

If a task cannot be completed:
1. Mark task `[!]` with explanation
2. Document the blocker in plan.md
3. Continue with non-blocked tasks if possible
4. Report blockers in execution summary

## Execution Summary

After completing all tasks (or hitting a blocker):

```markdown
## Execution Summary

**Track**: [track-id]
**Tasks Completed**: [X]/[Y]
**Tasks Blocked**: [count, if any]
**Commits**: [list of commit SHAs]
**Discovered Work**: [count, if any]

**Ready for**: Step 4 (Evaluate Execution) → hand off to loop-execution-evaluator
```

## Metadata Checkpoint Updates

The executor MUST update the track's `metadata.json` at key points:

### On Start
```json
{
  "loop_state": {
    "current_step": "EXECUTE",
    "step_status": "IN_PROGRESS",
    "step_started_at": "[ISO timestamp]",
    "checkpoints": {
      "EXECUTE": {
        "status": "IN_PROGRESS",
        "started_at": "[ISO timestamp]",
        "agent": "loop-executor",
        "tasks_completed": 0,
        "tasks_total": "[count from plan.md]",
        "commits": []
      }
    }
  }
}
```

### After Each Task (Critical for Resumption)
```json
{
  "loop_state": {
    "checkpoints": {
      "EXECUTE": {
        "status": "IN_PROGRESS",
        "tasks_completed": 3,
        "tasks_total": 10,
        "last_task": "Task 1.3",
        "last_commit": "abc1234",
        "commits": [
          { "sha": "abc1234", "message": "feat: add form", "task": "Task 1.3" }
        ]
      }
    }
  }
}
```

### On Completion
```json
{
  "loop_state": {
    "current_step": "EVALUATE_EXECUTION",
    "step_status": "NOT_STARTED",
    "checkpoints": {
      "EXECUTE": {
        "status": "PASSED",
        "completed_at": "[ISO timestamp]",
        "tasks_completed": 10,
        "tasks_total": 10,
        "last_task": "Task 3.2",
        "last_commit": "def5678",
        "commits": [...]
      },
      "EVALUATE_EXECUTION": {
        "status": "NOT_STARTED"
      }
    }
  }
}
```

### Update Protocol
1. read_file current `metadata.json` at start
2. Update `tasks_completed`, `last_task`, `last_commit` after EACH task
3. On completion: Advance `current_step` to `EVALUATE_EXECUTION`
4. write_file back to `metadata.json`

### Resumption Support
If executor is restarted mid-execution:
1. read_file `metadata.json.checkpoints.EXECUTE.last_task`
2. Find that task in `plan.md`
3. Continue from the NEXT `[ ]` task after the last completed one
4. Do NOT re-execute `[x]` tasks

## Handoff

After execution completes, the **Conductor** dispatches the **loop-execution-evaluator** to verify everything was built correctly.

Wersje

W bazie nie ma innych skilli o nazwie loop-executor.

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

  • 100loop-planner
    Tworzy szczegółowy plan wykonania nowej funkcji na podstawie spec.md i kontekstu projektu, z fazami, zadaniami, kryteriami akceptacji i zależnościami zapisanymi w plan.md.
  • 100implement
    Realizuje pojedyncze zadanie z planu w dyscyplinie TDD: czyta specyfikację, pisze testy, minimalny kod przechodzący, refaktoryzuje i robi commit.
  • 90build-from-plan
    Realizuje zatwierdzony plan w gałęzi funkcji, uruchamiając zakresowe testy i weryfikację po każdym zadaniu.
  • 95Implementation
    Wykonuje zadania z dokumentów zadań według TDD, fazami, z bieżącym śledzeniem postępu i weryfikacją każdego kroku.
  • 95unikit-implement
    Wykonuje zadania z gotowego planu funkcji w .unikit/code/plans/: czyta manifest PLAN.md, realizuje niedokończone zadania po kolei, oznacza postęp i wznawia pracę między sesjami.
  • 95execute-tdd-tasks
    Wykonuje pary zadań TDD autonomicznie z weryfikacją RED-GREEN-REFACTOR, orkiestrując wykonanie falami z równoległością i kierując zadania do odpowiednich agentów.

Uwagi i zgłoszenia

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