Skip to content
Development
Skill

/implement-backlog

Validate .turbo/backlog.md entries, recommend a working set, and run one lane: direct, investigate, or plan. Use when the user asks to \"implement the backlog\" or \"implement improvements\".

From plugin
turbo
42074 skills

Claude Code

$ npx -y skills add tobihagemann/turbo --skill implement-backlog --agent claude-code

SKILL.md

implement-backlog.SKILL.md
name: implement-backlog
description: "Validate .turbo/backlog.md entries, recommend a working set, and run one lane: direct, investigate, or plan. Use when the user asks to \"implement the backlog\" or \"implement improvements\"."

Implement Backlog

Validate improvements from `.turbo/backlog.md`, propose a specific working set based on the backlog's actual contents, and run one lane per session: direct, investigate, or plan. Mixing lanes in a single run tangles commits, so the skill processes exactly one lane each time. Entries outside the confirmed working set stay in the backlog for future runs.

When a working set and a lane were passed in, by the user or in a message from another session, start at Step 5 with them and create tasks for Steps 5 and 6 alone.

Task Tracking

At the start, use `TaskCreate` to create a task for each step:

1. Read the backlog 2. Validate and classify 3. Recommend, confirm, and update the backlog 4. Brief the extra sessions 5. Run the chosen lane 6. Prune working-set entries from the backlog

Step 1: Read the Backlog

Resolve the repo root with `git rev-parse --show-toplevel`, except inside a linked worktree — where `git rev-parse --git-dir` differs from `--git-common-dir` — in which case use the parent of the common dir.

When that root holds the legacy `.turbo/improvements.md`, carry it into `.turbo/backlog.md` before reading, with the Write or Edit tool. When `.turbo/backlog.md` does not exist, write the legacy content there with its `# Improvements` header changed to `# Backlog`. Otherwise, append each legacy entry that `.turbo/backlog.md` does not already hold word for word. Once `.turbo/backlog.md` holds every legacy entry, delete the legacy file. When the write or the deletion is refused, tell the user what is left to do.

Read `.turbo/backlog.md` under that root. If it does not exist, there are no backlog entries to implement; stop.

Parse all entries, extracting for each:

  • **Summary** (the `###` heading)
  • **Type** (`direct`, `investigate`, or `plan`; may be missing in older entries — `trivial` and `standard` are accepted as legacy aliases for `direct` and `plan`)
  • **Category**
  • **Where** (file paths or areas)
  • **Why** (rationale)
  • **Ceiling** and **Revisit** (present when the entry records a deliberate simplification; **Revisit** alone when the entry waits on an outside event)
  • **Noted** (date)

Step 2: Validate and Classify

Improvements drift: files get renamed, code gets refactored, issues get fixed as side effects of other work. Before routing, validate each improvement and settle the Type of any entry whose Type is missing or wrong.

Validate

For each entry, verify whether the specific problem or opportunity described still exists. Do not rely on git log alone. Recent commits touching the same files do not mean the specific issue was addressed. Read the actual code and confirm:

1. **Files exist** — Do the referenced files/paths still exist? When one was renamed or its code moved, validate the entry at the current location instead. This check marks the entry stale only when the code it names is gone. 2. **Problem persists** — Read the relevant code sections. Is the exact issue or opportunity described in the entry still present? Check the specific claims: if the entry says a function is uncalled, verify it has no callers; if it says error handling is missing, check whether it was added. 3. **Revisit condition met** — For an entry carrying a Revisit field, check whether the recorded condition now holds. A shipped simplification is present by construction, so its presence alone says nothing about whether the fuller version is worth building yet. 4. **Stated scope matches the real gap** — For an entry claiming missing coverage, read what existing tests already pin before accepting its scope: a test that substitutes a test double at a boundary pins the behavior on one side of it and leaves the boundary itself unpinned, so a request to cover several variants often reduces to the single boundary they share. Before dropping an item on the grounds that an existing check covers it, confirm that the check pins that item through its own inputs or match patterns rather than inferring it from the check's name or description; an item no existing check pins stays in the entry's scope. Restate such an entry at its real scope, classify it Active, and use the restatement as its summary in Step 3. 5. **Claimed consequence holds** — For an entry claiming that two paths behave differently, that a change would alter observable behavior, or that the code as it stands leads to a stated outcome, verify the consequence itself rather than confirming only that the code it points at exists. For a claimed difference, between two paths or between the behavior before and after a change, read what each actually returns, exercising both when reading cannot settle it. For a claimed outcome, follow the path from the named code to that outcome and confirm nothing later on that path already stops it. When the claim is that nothing but the case it names reaches or relies on the named code, read that code's own tests: they surface dependents an entry written from a single path routinely omits, and turning up none leaves the claim unproven. When the named code is present but its stated consequence is false, restate the entry at the benefit it actually delivers, classify it Active, and use the restatement as its summary in Step 3; classify it Stale when no benefit survives.

Before using a restatement as an entry's summary in Step 3, confirm each fact it adds to the entry against the code, or against the dependency's shipped artifact when the fact concerns a dependency. When the fact is that a dependency provides a capability, also confirm that the dependency's documentation says the capability is available, since code present in the shipped artifact can be gated off, internal, or not yet public.

Classify each entry as:

  • **Active** — The described p
Read more
@tobihagemann
Ships withturbo

A human-gated agentic software factory for Claude Code and Codex: you decide what to build and judge the result; skills shape, build, polish, ship, and learn.

Stars on GitHub

Momentum

stars in total
420
Star history of tobihagemann/turbo on GitHub, a chart by star-history.com

Other skills on turbo.

apply-turbo-handoffs

apply-turbo-handoffs

Audit the turbo lessons /self-improve wrote to .turbo/handoff/ and apply approved ones. Use when the user asks to \"read…

@tobihagemann@tobihagemannInstall Skill
apply-findings

apply-findings

Apply accepted review findings as code changes, escalating ambiguous ones to the user. Use when the user asks to \"apply…

@tobihagemann@tobihagemannInstall Skill
assess-technical-debt

assess-technical-debt

Assess project-wide technical debt (hotspots, deprecated APIs, duplication, low-value tests) into a ranked report. Use when the…

@tobihagemann@tobihagemannInstall Skill
backlog

backlog

Capture an out-of-scope improvement or accepted simplification in .turbo/backlog.md. Use proactively mid-task, or when the user…

@tobihagemann@tobihagemannInstall Skill
code-style

code-style

Enforce existence, reuse, mirror, and symmetry principles so new code stays minimal and consistent. Use when writing, changing,…

@tobihagemann@tobihagemannInstall Skill

More skills from other plugins.

brainstorming
Auto-invoked

brainstorming

You MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or…

@obra@obraInstall Skill
ask-matt

ask-matt

Ask which skill or flow fits your situation. A router over the skills in this repo.

skills2w309k
@mattpocock@mattpocockInstall Skill
accessibility
Auto-invoked

accessibility

Design, implement, and audit accessible UI to WCAG 2.2 Level AA across Web, iOS, and Android — semantic ARIA roles and labels,…

ecc2w293k
@affaan-m@affaan-mInstall Skill
compiler-commit

compiler-commit

Use when you want to verify compiler changes and commit with the correct convention. Runs tests, lint, and format, then commits…

react6d252k
@facebook@facebookInstall Skill

Questions about implement-backlog.

Which coding agents can use implement-backlog?
implement-backlog installs in Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode and Windsurf with the skills CLI, using each agent's flag shown on this page. Flowy's auto-invocation, which fires a skill when your prompt matches, runs in Claude Code only.