Skip to content
Skills Library
AI & agents · Automation

background-implementer

/background-implementer

Run bounded parallel implementation with isolated workers (native worktrees or Codex), respect a dependency DAG, and verify each worker's diff before integrating. Use only when the user explicitly requests background, parallel, or multi-agent implementation, such as "백그라운드 구현", "bg impl", or "병렬 구현". Do not trigger for ordinary implementation or code-writing requests.

Licence
MIT
Last repository change
01.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
3
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 01.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Run bounded parallel implementation with isolated workers (native worktrees or Codex), respect a dependency DAG, and verify each worker's diff before integrating. Use only when the user explicitly requests background, parallel, or multi-agent implementation, such as "백그라운드 구현", "bg impl", or "병렬 구현". Do not trigger for ordinary implementation or code-writing requests.

Triggers from the description

백그라운드 구현bg impl병렬 구현
Original author description

Run bounded parallel implementation with isolated workers (native worktrees or Codex), respect a dependency DAG, and verify each worker's diff before integrating. Use only when the user explicitly requests background, parallel, or multi-agent implementation, such as "백그라운드 구현", "bg impl", or "병렬 구현". Do not trigger for ordinary implementation or code-writing requests.

How it works

  1. 1. Decompose into a task DAG
  2. 2. Wave execution
  3. 3. Assign and isolate workers
  4. 4. Integration gate
  5. 5. Iterate (optional)
  6. Token efficiency
  7. Best practices
  8. Safety
  9. Version Notes
Original SKILL.md headings · 127 lines, 731 words
SKILL.md preview
---
name: background-implementer
description: Run bounded parallel implementation with isolated workers (native worktrees or Codex), respect a dependency DAG, and verify each worker's diff before integrating. Use only when the user explicitly requests background, parallel, or multi-agent implementation, such as "백그라운드 구현", "bg impl", or "병렬 구현". Do not trigger for ordinary implementation or code-writing requests.
trigger-keywords: [bg impl, 백그라운드 구현, 병렬 구현, parallel implementation, multi-agent implementation]
tags: [implementation, parallel, multi-agent, worktree]
---

# Background Implementer

Implement independent tasks with isolated parallel workers, then integrate only the
diffs that pass verification — in dependency order.

Mechanics (worker invocation, provider recipes, worktree isolation, `.context/` layout,
token discipline) live in `references/orchestration.md`. This file owns the workflow,
the schema, and the integration gate.

## 1. Decompose into a task DAG

From the plan (or the request), extract independent units and their dependencies:

```yaml
- id: T1
  feature: db-migration
  files: [migrations/…]
  depends_on: []
  provider: codex          # who implements it (see §3)
  verify: how to check it (test cmd, build, manual assertion)
- id: T2
  feature: models
  depends_on: [T1]
```

Typical ordering: migrations → models → handlers/services → frontend. Independent leaves
(migrations, types, frontend scaffolding) parallelize; dependents wait.

## 2. Wave execution

Run tasks in dependency waves; parallelize within a wave, barrier between waves.

```
Wave 1 (parallel): migration + types + frontend scaffold
Wave 2 (needs migration): models
Wave 3 (needs models): handlers
```

Only start a wave once its dependencies are integrated and verified (§4).

## 3. Assign and isolate workers

Choose the provider per task, then give each writer its **own git worktree** — never let
two workers edit the same files (see orchestration reference for the isolation recipe).

| Provider | Best for | Isolation |
|----------|----------|-----------|
| host-native sub-agent (Claude) | complex logic, multi-file changes, deep codebase reading | `isolation: worktree` frontmatter / `EnterWorktree` |
| Codex `exec` | focused code gen, migrations, models | manual `git worktree add` per worker |

Prefer the host's **native** worker + native worktree isolation. Use Codex only as a
cross-tool fallback or when the user explicitly asks for it.

Pass each worker its task **by file path** (not inline), scoped to one `id`, with its
`verify` command. Tell every worker: **do not commit** — leave the worktree dirty for the
orchestrator to inspect and apply.

Codex worker recipe (note the global `-a`/`-C` placement — the common breakage):

```bash
codex -C "$WT" -a never exec -s workspace-write \
  -o "$PROJ/.context/impl/${ROUND}-codex-${FEATURE}.md" \
  - < "$PROJ/.context/impl/${ROUND}-codex-${FEATURE}.prompt.md"
```

`workspace-write` has no network by default and protects `.git`; install deps up front
and do not rely on the worker committing. Use `--output-schema` if you need the worker's
summary in a fixed JSON shape.

## 4. Integration gate

Prefer the host's native wait/notification. When a worker finishes, do **not** apply its
work blindly:

1. Inspect the worker's notes **and** its actual worktree diff (`git -C "$WT" diff`).
2. Run the task's `verify` command against the worktree. A worker's claim of success is
   not evidence — the passing check is.
3. Reject overlapping, out-of-scope, or unverified changes.
4. Apply accepted diffs to the main checkout **in dependency order**, then remove the
   worktree.
5. Run the relevant tests after each integration; summarize remaining failures honestly.

Only fire-and-forget (launch and return immediately) when the user explicitly asks for it.

## 5. Iterate (optional)

If verification fails or the user requests fixes, run `R02` on the affected tasks only.
Stop when all tasks integrate cleanly and their verifications pass, when a fix needs a
decision not yet authorized, or at the user's round/token bound.

## Token efficiency

- Write task instructions to a `.md` file; pass the path, not the body.
- Workers return compact structured summaries; the orchestrator reads summaries, not full
  transcripts (open a worker's output only when the summary is insufficient).
- Keep prompts, logs, and summaries in `.context/impl/` so the main conversation stays lean.

## Best practices

**Do**
- Respect dependency order (migration → models → handlers).
- One worktree per writer; verify before integrating.
- Wait for bounded workers via notification, not polling.

**Don't**
- Tight-poll worker processes or run 10+ workers at once.
- Let multiple workers edit the same file.
- Hand unverified diffs to the main checkout, or hand unfinished verification back to the
  user unasked.

## Safety

- Workers must not commit, push, or open PRs; the orchestrator integrates after review.
- `-s danger-full-access` / `--dangerously-bypass-approvals-and-sandbox` only inside an
  externally isolated or disposable worktree runner.
- Non-interactive workers cannot pause for approval — out-of-sandbox actions fail rather
  than prompt. Scope sandboxes deliberately.
- Preserve unrelated user changes; never discard a dirty worktree without inspecting it.

## Version Notes

- Worker/provider recipes verified against current Claude Code sub-agents (native
  worktree isolation), `codex-cli`, and `gemini-cli` on 2026-07-23. Re-check
  `codex exec --help` before changing recipes; Codex flags move fast. See
  `references/orchestration.md`.
Files in this package (3)
  • SKILL.md 6 KB
  • agents/openai.yaml 1 KB
  • references/orchestration.md 6 KB

Versions

The database has no other skills named background-implementer.

Database snapshot: 13.11.2026 · package version 5265fbcef6fc (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100background-planner
    Run bounded parallel planning with independent planner personas and optional multi-LLM workers, then synthesize a single plan via stance-steered consensus with explicit conflicts and open questions. Use only when the user explicitly requests background, parallel, or multi-agent…
  • 98subtask4llm-codex
    Execute a multi-step software change through separate, sequential Codex workers with bounded retries and detailed, relevant handoffs. Use when the user explicitly invokes $subtask4llm-codex or asks to carry out a dependency-ordered implementation plan with isolated worker…
  • 98subtask4llm-pi
    Plan and run a dependency-ordered software change through sequential, one-shot Pi workers with bounded retries and explicit dependency handoffs. Use for authorized multi-step implementation work that benefits from isolated worker contexts; avoid it for planning-only requests or…
  • 100codex-delegation
    Use when a coding task would benefit from delegating work to Codex in the background — a deep independent second opinion, security or architecture analysis, or a parallel implementation running while the session continues. Lets Claude drive the codex companion itself (task,…
  • 100codex-delegate
    Delegate a coding task to the OpenAI Codex CLI as a background implementer, then review its diff and land it yourself. Use this whenever the user wants to hand implementation work to Codex — phrasings like "have Codex do X", "delegate this to Codex", "run it through Codex", or…
  • 100agent-spawn
    Use when launching parallel tmux agents with optional isolated Git worktrees under Oh My Harness.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.