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

delegate-issue

/delegate-issue

Deleguje dobrze określone zadania programistyczne do węzła SWE-AF jako taniego pod-harnessa przez implement_issue, a następnie zbiera i scala zwrócone gałęzie, także równolegle dla niezależnych zmian.

Repozytorium
swe-af ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
20.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
2
Przestarzałość

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

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Deleguje dobrze określone zadania programistyczne do węzła SWE-AF jako taniego pod-harnessa przez implement_issue, a następnie zbiera i scala zwrócone gałęzie, także równolegle dla niezależnych zmian.

Oryginalny opis (EN)

Delegate well-scoped coding issues to a SWE-AF node as a cheap sub-harness via implement_issue, then collect and merge the returned branches. Use when the user asks to offload, delegate, or fan out scoped tasks to SWE-AF / swe-planner / swe-fast, or when several independent, fully-specified changes could run in parallel without burning main-harness tokens.

Jak działa

  1. When to delegate (and when not to)
  2. Preflight (once per session)
  3. Compose the issue
  4. Fire the delegation (async, never sync)
  5. Track progress
  6. Collect the result
Sekcje z nagłówków SKILL.md, w oryginale · 113 linii, 584 słów
Podgląd SKILL.md
---
name: delegate-issue
description: Delegate well-scoped coding issues to a SWE-AF node as a cheap sub-harness via implement_issue, then collect and merge the returned branches. Use when the user asks to offload, delegate, or fan out scoped tasks to SWE-AF / swe-planner / swe-fast, or when several independent, fully-specified changes could run in parallel without burning main-harness tokens.
---

# Delegate scoped issues to SWE-AF

You are the main harness. SWE-AF is the sub-harness: it implements one
fully-scoped issue per call on an isolated branch, using cheap models, and
hands the branch back. You keep planning, merging, review, and CI.

## When to delegate (and when not to)

Delegate an issue only when ALL of these hold:

- The change is **fully specified**: you can name the files, the behavior, and
  the acceptance criteria without the sub-harness needing to plan anything.
- It is **independent** of your other in-flight edits (no shared files with
  another delegation or with your own uncommitted work).
- The repo is reachable by the SWE-AF node (same machine or shared volume) and
  has at least one commit.

Do NOT delegate: vague feature requests (use `swe-planner.build` instead),
changes to files you are editing yourself right now, or anything whose spec
you'd have to guess. Garbage spec in → garbage branch out.

## Preflight (once per session)

```bash
# Control plane up and the node registered?
curl -s ${AGENTFIELD_SERVER:-http://localhost:8080}/api/v1/nodes | grep -o '"swe-[a-z-]*"' | sort -u
```

Pick the node (`swe-planner`, `swe-fast`, or the `-go` twins — the
`implement_issue` surface is identical). If an `X-API-Key` is configured for
the control plane, add `-H "X-API-Key: $AGENTFIELD_API_KEY"` to every curl.

## Compose the issue

Write the spec from YOUR context — the whole point is that the sub-harness
skips planning. Required: `title`, `description`. Strongly recommended:
`acceptance_criteria` (verifier checks these), `files_to_modify` /
`files_to_create`, `testing_strategy`. Set `needs_deeper_qa: true` only for
risky/interface-heavy changes (doubles the review cost per iteration).

Commit (or at least be aware of) your local state first: the issue branch is
created from the **committed** base, so your uncommitted edits are invisible
to it.

## Fire the delegation (async, never sync)

```bash
curl -s -X POST ${AGENTFIELD_SERVER:-http://localhost:8080}/api/v1/execute/async/swe-planner.implement_issue \
  -H "Content-Type: application/json" \
  -d @issue.json
```

with `issue.json` shaped like:

```json
{
  "input": {
    "issue": {
      "title": "...",
      "description": "...",
      "acceptance_criteria": ["..."],
      "files_to_modify": ["..."],
      "testing_strategy": "..."
    },
    "repo_path": "/abs/path/to/checkout",
    "base_branch": "main",
    "config": { "models": { "default": "haiku" } }
  }
}
```

Capture `execution_id` from the 202 response. Track every in-flight
delegation in your todo list (one item per execution_id).

**Cap fan-out at 3 concurrent delegations per repo** unless the user
explicitly asks for more — each one is a paid multi-agent run, and an
unbounded loop of delegations is a surprise bill. Never re-fire a delegation
just because it is slow; poll it.

## Track progress

```bash
# Terminal status + result
curl -s $SERVER/api/v1/executions/<execution_id>
# Live agent notes (what the coder/reviewer are doing)
curl -s $SERVER/api/v1/executions/<execution_id>/notes
```

Poll on a backoff (30–60s is plenty; a typical issue lands in 10–30 min).
Batch-check several: `POST /api/v1/executions/batch-status` with
`{"execution_ids": [...]}`.

## Collect the result

The execution's `result` is an IssueBuildResult:

- `success: true` → `branch` holds the implementation
  (`issue/<build_id>-<slug>`). Review the diff yourself
  (`git diff main...<branch>`), run YOUR test gate, then merge:
  `git merge --no-ff <branch>` (or cherry-pick), and delete the branch.
- `success: false` with a `branch` → partial work was salvaged. Triage:
  read `verification` / `debt_items` / `error_message`, then either fix
  forward on the branch yourself, re-delegate with a sharpened spec, or drop
  the branch (`git branch -D`).
- `success: false` with `branch: ""` → nothing usable was produced; the
  sub-harness already cleaned up. Sharpen the spec before retrying — do not
  retry verbatim.

After merging all accepted branches, run the project's full test suite once
yourself before reporting done. The sub-harness verifier is a per-issue
check, not your integration gate.

Wersje

W bazie nie ma innych skilli o nazwie delegate-issue.

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

  • 100mini-swe-evolution-guide
    Pomaga rozwijać harness agenta mini-SWE: prompt, przepływ sterowania, narzędzia E2B i walidację.
  • 100open-swe
    Wdraża i konfiguruje Open SWE od LangChain, asynchronicznego agenta kodującego, który przyjmuje zadania z dashboardu, GitHuba, Slacka lub Linear, pracuje w izolowanym środowisku i otwiera pull requesty.
  • 100pi-delegate
    Deleguje zadania programistyczne do agenta CLI Pi (pi) wyłącznie na wyraźną prośbę użytkownika, a przegląd i scalenie zostają po stronie orkiestratora.
  • 100pi-delegate
    Deleguje zadania programistyczne do agenta CLI Pi (pi) wyłącznie na wyraźną prośbę użytkownika, a przegląd i scalenie zostają po stronie orkiestratora.
  • 90add-benchmark
    Dodaje nowe zadanie SWE z poprawki błędu na GitHubie do potoku bench-swe na podstawie linku do issue lub PR.
  • 100pi-delegate
    Przekazuje zadanie programistyczne agentowi Pi CLI jako wykonawcy w tle, a następnie sprawdza jego diff i samodzielnie wprowadza zmianę do repozytorium.

Uwagi i zgłoszenia

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