Skip to main content
skill CX Codex

plan-to-issues — Claude Code skill: turn a plan into tracked tasks

plan-to-issues converts a plan discussed in the chat into structured GitHub issues: an epic plus child tasks grouped by milestone and labeled by type. Triggers on command or keywords like "split plan into tasks" or "make issues from this".

MIT ★ 74 updated 2026-10-29

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add corezoid/corezoid-ai-plugin --skill plan-to-issues -a claude-code
Open on GitHub

What plan-to-issues does

The skill reads the plan directly from chat history—no files, no URLs. It parses the discussion, breaks the plan into independent, shippable work items, and creates them in the corezoid/corezoid-ai-plugin repository. Each child issue contains the goal, context, affected files, acceptance criteria, and verification commands—enough for a coder to open it and start immediately.

Every task receives a type label (enhancement, bug, documentation, refactor, tests) and a shared ai label for easy filtering. The plan becomes a milestone with a name and brief summary. If tasks have dependencies, the skill records which ones block which. All issue titles, bodies, labels, and milestone text are published in English, regardless of the language the plan was discussed in—this is a project requirement. Sensitive URLs or credentials from the chat are not posted to issues.

What it helps with

  • split a complex plan into discrete, shippable tasks for different engineers
  • create GitHub issues with full context, acceptance criteria and verification steps in one action
  • link child tasks to an epic and group them under a milestone
  • translate a plan discussed in Russian to English-language GitHub issues

Example prompts for the agent

  • Ask: "Split this plan into tasks and create the issues" — the skill finds the plan in history and creates them
  • Say: "Make issues from these steps in corezoid-ai-plugin and set up the epic" — creates a milestone with child tasks
  • Command: "Post this as tracked work in GitHub" — turns the plan into classified issues with dependencies

How to install plan-to-issues

1Skills CLI (Vercel)

npx skills add corezoid/corezoid-ai-plugin --skill plan-to-issues -a claude-code

2Manually: put the files in place

~/.claude/skills/plan-to-issues/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/plan-to-issues/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about plan-to-issues

How do I install plan-to-issues in Claude Code?

Run npx skills add corezoid/corezoid-ai-plugin --skill plan-to-issues -a claude-code. The skill will then be available at ~/.claude/skills/plan-to-issues/SKILL.md.

What does plan-to-issues do?

It reads a plan from the current chat, breaks it into independent, reviewable tasks, and creates GitHub issues in the corezoid/corezoid-ai-plugin repository. Each issue includes the goal, context, files to modify, acceptance criteria, and test commands. All tasks are grouped under an epic, assigned to a milestone, and labeled by type (enhancement, bug, documentation, refactor, tests).

Do I need to set anything up beforehand?

No. Simply discuss the plan in the chat with your agent—the skill reads the history, finds the plan, and creates issues automatically. You must have access to the corezoid/corezoid-ai-plugin repository to create issues.

Source text

SKILL.md · MIT
---
name: plan-to-issues
description: >
  Turns a work plan discussed in the current conversation into a structured set
  of GitHub issues in the corezoid/corezoid-ai-plugin repo: one parent epic
  issue plus one child issue per logical task, grouped by a milestone and
  typed with labels. Use whenever the user says "заведи задачи", "создай
  issues", "разбей план на задачи", "plan to issues", "план в issues",
  "нарежь план", "нарезать план", "заведи эпик", "create epic", "split plan
  into tasks", or asks to turn a plan / roadmap / TODO discussed in chat into
  tracked GitHub work items. Also trigger when the user pastes a plan and
  asks to "заведи это в гитхаб" / "put this in github" / "make issues out of
  this".
---

# Plan → GitHub Issues

Turn a plan already discussed in this conversation into a tracked set of
GitHub issues. **No file input, no URL fetching** — the plan lives in the
chat history above the invocation. Read it, split it, ship it.

Repo is fixed: `corezoid/corezoid-ai-plugin` (this project). All `gh` commands
run against the current repo — do not pass `--repo`.

## Non-negotiables

- **English only.** Every issue — title, body, labels, milestone title and
  description — MUST be written in English, regardless of the language the
  plan was discussed in. Translate the plan as you split it. This is
  non-negotiable: never publish Russian, Ukrainian, or any other language
  to GitHub. If a term is a project-specific proper noun (node type name,
  file path, CLI flag, tool name) keep it verbatim; everything else is
  English prose.
- **Create immediately.** The user has pre-authorised issue creation for this
  skill. Do not ask "shall I create these?" Do the work and report what was
  created.
- **Every child issue is self-contained** — a coding agent must be able to
  open the issue and start work with zero extra context. That means: goal,
  motivation, files/areas, acceptance criteria, verification, and links to
  related tasks are all inside the body.
- **Never invent tasks.** If the plan is vague on a point, mark it in the
  issue as `> ⚠ Assumption:` rather than silently filling gaps.
- **Never post secrets or internal URLs** into issue bodies. Redact if the
  chat history contains any.

## Workflow

### 1. Extract the plan from context

Scroll the current conversation for the plan. Signals: a numbered list of
steps, a bulleted roadmap, a "TODO / next steps" block, or a design outline
the user explicitly called a plan. If there are competing plans, use the
**most recent** one the user endorsed.

If you truly can't find a plan in the context, stop and ask the user to
paste it — do not fabricate.

### 2. Split into logical tasks

Each task should be:

- **Independently shippable** — mergeable as its own PR.
- **Bounded** — a coding agent can finish it in one focused sitting.
- **Ordered by dependency** — if B needs A merged first, list A first and
  record the dependency in B.

Aim for 3–10 child tasks. If the plan naturally produces 1–2, skip the epic
and just create standalone issues. If it produces 15+, group into phases and
make each phase its own child (with sub-bullets inside the body) rather than
one issue per micro-step.

### 3. Classify each task → label

Map the task's dominant nature to an existing repo label:

| Task nature | Label |
|---|---|
| New capability, new tool, new skill, new node type | `enhancement` |
| Fixing broken behaviour | `bug` |
| Docs, README, comments, examples | `documentation` |
| Refactor, cleanup, dead-code removal | `refactor` *(create if missing — see step 4)* |
| Test-only work | `tests` *(create if missing)* |

One primary label per issue. Add `ai` (existing repo label) to every issue
this skill creates, so they're easy to filter later.

### 4. Ensure labels exist

Before creating issues, ensure the labels you're about to apply exist. Run:

```bash
gh label list --limit 200 --json name -q '.[].name'
```

For each label you need that's missing, create it:

```bash
gh label create refactor --color "fbca04" --description "Code refactor / cleanup"
gh label create tests    --color "0e8a16" --description "Test-only changes"
```

Do NOT recreate existing labels; `gh label create` errors on duplicates.

### 5. Create the milestone

Name the milestone from the plan's headline goal, kept short (≤50 chars).
Example: "Convctl streaming refactor", "Marketplace publish v2".

```bash
gh api repos/:owner/:repo/milestones \
  --method POST \
  -f title="<milestone title>" \
  -f description="<one-line summary of the plan>" \
  -f state="open" \
  --jq '.number'
```

Capture the returned milestone number — child issues need it.

If a milestone with the same title already exists, reuse it: list with
`gh api repos/:owner/:repo/milestones -q '.[] | {number,title}'` and pick
the matching `number`.

### 6. Create child issues

For each task, in dependency order, create an issue with the full body
template below. Capture each returned issue number — the epic will link them.

```bash
gh issue create \
  --title "<type>: <short imperative title>" \
  --label "<primary-label>,ai" \
  --milestone <milestone-number> \
  --body-file /tmp/plan-to-issues-child-N.md
```

Title format: `<type>: <imperative summary>` where `<type>` is one of
`feat`, `fix`, `docs`, `refactor`, `test`, `chore` — matches the repo's
commit convention (see `.claude/skills/commit/SKILL.md`).

Write the body to a temp file first (bodies are long and multiline). Use
this template verbatim, filling every section — do not omit sections; if a
section is genuinely N/A, write `_None._` so the reader knows it was
considered.

```markdown
## Goal

<One-sentence outcome. What does "done" look like from the outside?>

## Context

<Why this task exists. Link back to the plan / conversation motivation.
If it's part of a larger effort, state that here. Include background a
fresh coding agent would not otherwise have.>

## Scope

**In scope:**
- <specific change 1>
- <specific change 2>

**Out of scope:**
- <thing that might look adjacent but is a separate task>

## Files / areas to touch

- `path/to/file.go` — <what changes here>
- `path/to/other.md` — <what changes here>

<If the exact files aren't known yet, list the directory or module and mark
it `> ⚠ Assumption: agent to confirm exact files during discovery.`>

## Acceptance criteria

- [ ] <observable behaviour 1>
- [ ] <observable behaviour 2>
- [ ] <docs / changelog updated if applicable>
- [ ] <existing tests still green>

## Verification

<Exact commands the agent should run before opening a PR. Prefer the
project's canonical commands from CLAUDE.md.>

```bash
cd plugins/corezoid/mcp-server
go build ./...
go vet ./...
go test -race ./...
```

## Dependencies

- Blocked by: #<issue-number-or-none>
- Blocks: #<issue-number-or-none>
- Related: #<issue-number-or-none>

## Notes

<Optional. Edge cases, gotchas, links to node-structures.md sections,
lint rules, prior PRs. Anything a coding agent would ask before starting.>
```

Fill `Blocked by` on later issues by referencing earlier child numbers you
already captured. `Blocks` and `Related` can be filled after all children
exist — patch the body in a second pass if needed:

```bash
gh issue edit <N> --body-file /tmp/plan-to-issues-child-N.md
```

### 7. Create the parent epic

After all children exist, create the parent epic. Its body is a task list of
child issues — GitHub renders `- [ ] #N` as a live tracked sub-issue.

```bash
gh issue create \
  --title "Epic: <plan headline>" \
  --label "enhancement,ai" \
  --milestone <milestone-number> \
  --body-file /tmp/plan-to-issues-epic.md
```

Epic body template:

```markdown
## Goal

<One-paragraph description of the plan and the outcome once all sub-tasks land.>

## Motivation

<Why now, who asked, what problem this solves. Pull from the conversation.>

## Sub-tasks

- [ ] #<child-1>
- [ ] #<child-2>
- [ ] #<child-3>

## Milestone

Tracked under milestone: **<milestone title>**.

## Notes

<Optional. Cross-cutting concerns, rollout order, feature flags, risk.>
```

### 8. Back-link children to the epic (best-effort)

For each child, append `Part of #<epic-number>` to the top of its body so
the linkage is visible on the child page too. Use `gh issue edit --body-file`.
Skip if this would double the work for a plan with only 2–3 children.

### 9. Report to the user

Output a compact summary — no fluff:

```
Epic: #<epic-number> <title>
Milestone: <title> (#<milestone-number>)
Children:
  #<n> <type>: <title>
  #<n> <type>: <title>
  ...
```

Include full URLs only if the user asked for them explicitly.

## Guardrails

- **Do not** open PRs, push branches, or run any code changes — this skill
  only files work items.
- **Do not** assign issues to users unless the user in this session named a
  specific GitHub handle to assign.
- **Do not** close or edit existing unrelated issues.
- **Do not** delete milestones or labels, even if they look stale.
- If `gh` returns an error (rate limit, permission, network), stop, report
  what succeeded and what didn't, and let the user decide whether to retry.
  Do not retry destructive operations silently.

## Cleanup

Delete `/tmp/plan-to-issues-*.md` scratch files after successful creation.
Leave them if any step failed, so a retry can reuse them.

© corezoid · MIT · corezoid/corezoid-ai-plugin

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set30

The whole set →
corezoid-lifecycle The corezoid-lifecycle skill for Claude Code pauses, resumes, or relocates Corezoid processes and folders only on explicit user instruction. CX Codex +1 ★ 74repo stars corezoid-retro corezoid-retro — a skill that analyzes a completed Corezoid work session, extracts actionable insights, and stores them as workspace CLAUDE.md updates, team feedback, and permission rules. Every session teaches the next one. CX Codex +1 ★ 74repo stars corezoid-dashboard-manager corezoid-dashboard-manager is a Claude Code skill that builds Corezoid dashboards via cz-dashboards, mapping process node task counters to charts and setting grid layouts. CX Codex +1 ★ 74repo stars corezoid-git-context The corezoid-git-context skill records meaningful Corezoid session changes in stage documentation and syncs the git mirror. Use it after real process work. CX Codex +1 ★ 74repo stars corezoid-state-diagram-edit corezoid-state-diagram-edit — a skill for updating Corezoid state diagrams in .conv.json files. Adjusts states, transition paths, and transition side effects. CX Codex +1 ★ 74repo stars corezoid-node-layout corezoid-node-layout arranges Corezoid process nodes into a readable top-to-bottom flow and moves error handling to the right. Use it before pushing a new process or after a layout request. CX Codex +1 ★ 74repo stars corezoid-access corezoid-access — a skill for managing access to processes, folders and projects in Corezoid. Share objects with users and groups, create API keys, invite external users, and audit who has access. CX Codex +1 ★ 74repo stars corezoid-project-review corezoid-project-review audits entire Corezoid projects or folders, finding circular calls, duplicate code logic, and shared hardcoded secrets. CX Codex +1 ★ 74repo stars

Project sponsors

Companies that keep this analytics open