Skip to main content
subagent CX Codex

speckit.taskstoissues — Claude Code subagent: what it does

speckit.taskstoissues turns the task list from tasks.md into numbered GitHub issues while keeping dependency order. Handy when the plan is already broken into tasks but the tracker is empty.

MIT ★ 110 updated 2026-10-19

Install into GitHub Copilot · Manually: put the files in place All methods and platforms ↓
.github/agents/speckit.taskstoissues.agent.md
Open on GitHub

What speckit.taskstoissues does

It reads tasks.md, drops the checkbox and the [P]/[US#] markers, then opens one issue per task with a title like T001: <description>. GitHub access goes through the MCP server tools list_issues and issue_write. Ahead of that it runs .specify/scripts/bash/check-prerequisites.sh --json --require-tasks --include-tasks and reads the origin remote; anything that is not a GitHub URL stops the run.

A second run will not duplicate work. Existing issue titles are fetched and matched against T\d{3,}, and tasks whose ID already appears are skipped with a short note. Hooks under before_taskstoissues and after_taskstoissues in .specify/extensions.yml get picked up too, and the mandatory ones have to finish before conversion continues.

The deprecation label is real: the command goes away in a future minor release. Its replacement is the bundled github extension, added with specify extension add github and called as /speckit.github.taskstoissues. The agent prints the warning and carries on, leaving the extension install to you. File paths differ per platform: .claude/agents/speckit.taskstoissues.md for Claude, .codex/agents/speckit.taskstoissues.toml for Codex. No GitHub MCP server with list_issues and issue_write means no issues.

What it helps with

  • turn tasks.md into numbered GitHub issues
  • skip tasks that already have an issue on a re-run
  • keep dependency order between created issues
  • check that origin points at GitHub before writing
  • run project hooks around the conversion

Example prompts for the agent

  • Open GitHub issues for every task in tasks.md for this feature.
  • Create issues for T010–T020 and list the ones you skipped.
  • Check .specify/extensions.yml for before_taskstoissues hooks, then run the conversion.

How to install speckit.taskstoissues

Manually: put the files in place

.github/agents/speckit.taskstoissues.agent.md

Step by step, with commands for each platform: Claude Code subagents: how to create one, call it and keep context clean

Questions about speckit.taskstoissues

How do I install speckit.taskstoissues in Claude Code?

Copy the subagent file into your project at .claude/agents/speckit.taskstoissues.md.

What does speckit.taskstoissues do?

It reads the feature's tasks.md, checks against issues that already exist, and creates one GitHub issue per task with the task ID in the title. A GitHub MCP server with list_issues and issue_write is required.

Is speckit.taskstoissues deprecated?

Yes, it will be removed in a future minor release. The bundled github extension takes over: specify extension add github, then /speckit.github.taskstoissues.

Source text

speckit.taskstoissues.agent.md · MIT
---
description: "Deprecated: Convert existing tasks into actionable, dependency-ordered GitHub issues for the feature based on available design artifacts."
tools: ['github/github-mcp-server/list_issues', 'github/github-mcp-server/issue_write']
---

## Deprecation Notice

You **MUST display the following concise warning first**, as the first step of this command and before the User Input and Pre-Execution Checks sections below:

> ⚠️ `/speckit.taskstoissues` is deprecated and will be removed in a future minor release. Use the bundled `github` extension instead: run `specify extension add github`, then invoke `/speckit.github.taskstoissues`.

Continue with the existing workflow unchanged. Do not install or enable the extension automatically, do not stop, and do not run the replacement command.

## User Input

```text
$ARGUMENTS
```

You **MUST** consider the user input before proceeding (if not empty).

## Pre-Execution Checks

**Check for extension hooks (before tasks-to-issues conversion)**:
- Check if `.specify/extensions.yml` exists in the project root.
- If it exists, read it and look for entries under the `hooks.before_taskstoissues` key
- If the YAML cannot be parsed or is invalid, do not skip silently: tell the user that `.specify/extensions.yml` could not be read (include the parser error) and that no hooks were checked, including any mandatory (`optional: false`) hooks registered there, then continue normally
- Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
- For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
  - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
  - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
- For each executable hook, output the following based on its `optional` flag:
  - **Optional hook** (`optional: true`):
    ```
    ## Extension Hooks

    **Optional Pre-Hook**: {extension}
    Command: `/{command}`
    Description: {description}

    Prompt: {prompt}
    To execute: `/{command}`
    ```
  - **Mandatory hook** (`optional: false`):
    ```
    ## Extension Hooks

    **Automatic Pre-Hook**: {extension}
    Executing: `/{command}`
    EXECUTE_COMMAND: {command}

    Wait for the result of the hook command before proceeding to the Outline.
    ```
    After emitting the block above you MUST actually invoke the hook and wait for it to finish before continuing. Run it the same way you would run the command yourself in this agent/session (the invocation may differ from the literal `{command}` id shown above, e.g. a skills-mode agent runs it as `/skill:speckit-...` or `$speckit-...`). Emitting the block alone does not run the hook.
- If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently

## Outline

1. Run `.specify/scripts/bash/check-prerequisites.sh --json --require-tasks --include-tasks` from repo root and parse FEATURE_DIR and AVAILABLE_DOCS list. All paths must be absolute. For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'\''m Groot' (or double-quote if possible: "I'm Groot").
1. **IF EXISTS**: Load `.specify/memory/constitution.md` for project principles and governance constraints.
1. From the executed script, extract the path to **tasks**.
1. Get the Git remote by running:

```bash
git config --get remote.origin.url
```

> [!CAUTION]
> ONLY PROCEED TO NEXT STEPS IF THE REMOTE IS A GITHUB URL

1. **Fetch existing issues for deduplication**: Before creating anything, build the set of task IDs you are about to process from `tasks.md` (each is a `T` followed by **at least** three digits, e.g. `T001` — `/speckit.converge` assigns new IDs with `T{M+1:03d}`, which is a floor rather than a cap, so once a file has more than 999 tasks the IDs are four digits or longer). Then use the GitHub MCP server's `list_issues` tool to look for issues that already cover those IDs. Do not pass a `state` value, since omitting it makes the tool return both open and closed issues. Request `perPage: 100` to keep the number of calls down, and since the tool uses cursor-based pagination, request pages with the `after` parameter (using the `endCursor` from the previous response). For each issue title, match it against the task ID pattern `\bT\d{3,}\b` (the `{3,}` accepts four-digit and longer IDs — with `\d{3}` a title containing `T1000` would not match at all, because the trailing `\b` cannot fall between two digits, so that task would be silently neither deduplicated nor created; word boundaries still stop a token like `ST001` from matching, and force the whole digit run to be consumed so `T100` can never match inside `T1000`; this also recognises titles written as `T001 ...`, `T001: ...` or `[T001] ...`) and, when it matches one of your task IDs, mark that ID as already having an issue. Stop paginating as soon as every task ID has been matched, or when there are no more pages, so you do not keep fetching the whole repository's issue history once all task IDs are accounted for. This bounds the number of calls on repos with large issue histories and still prevents duplicates when the command is re-run after `tasks.md` is regenerated or the skill is re-invoked.
1. For each task in the list, use the GitHub MCP server to create a new issue in the repository that is representative of the Git remote. Task lines in `tasks.md` start with a markdown checkbox, so first strip the leading `- [ ]` (and any `[P]` / `[US#]` markers) to recover the task ID and its description. Create the issue with a single canonical title of the form `T001: <description>`, with the ID written once followed by the task description (for example, the line `- [ ] T001 Create project structure` becomes the title `T001: Create project structure`).
   - **Skip** any task whose ID is already present in the set of existing issues from the previous step, and report it (for example, `T001 already has an issue, skipping`).
   - Only create issues for tasks that do not yet have a matching issue.

> [!CAUTION]
> UNDER NO CIRCUMSTANCES EVER CREATE ISSUES IN REPOSITORIES THAT DO NOT MATCH THE REMOTE URL

## Post-Execution Checks

**Check for extension hooks (after tasks-to-issues conversion)**:
Check if `.specify/extensions.yml` exists in the project root.
- If it exists, read it and look for entries under the `hooks.after_taskstoissues` key
- If the YAML cannot be parsed or is invalid, do not skip silently: tell the user that `.specify/extensions.yml` could not be read (include the parser error) and that no hooks were checked, including any mandatory (`optional: false`) hooks registered there, then continue normally
- Filter out hooks where `enabled` is explicitly `false`. Treat hooks without an `enabled` field as enabled by default.
- For each remaining hook, do **not** attempt to interpret or evaluate hook `condition` expressions:
  - If the hook has no `condition` field, or it is null/empty, treat the hook as executable
  - If the hook defines a non-empty `condition`, skip the hook and leave condition evaluation to the HookExecutor implementation
- For each executable hook, output the following based on its `optional` flag:
  - **Optional hook** (`optional: true`):
    ```
    ## Extension Hooks

    **Optional Hook**: {extension}
    Command: `/{command}`
    Description: {description}

    Prompt: {prompt}
    To execute: `/{command}`
    ```
  - **Mandatory hook** (`optional: false`):
    ```
    ## Extension Hooks

    **Automatic Hook**: {extension}
    Executing: `/{command}`
    EXECUTE_COMMAND: {command}
    ```
    After emitting the block above you MUST actually invoke the hook and wait for it to finish before continuing. Run it the same way you would run the command yourself in this agent/session (the invocation may differ from the literal `{command}` id shown above, e.g. a skills-mode agent runs it as `/skill:speckit-...` or `$speckit-...`). Emitting the block alone does not run the hook.
- If no hooks are registered or `.specify/extensions.yml` does not exist, skip silently

© alfredoperez · MIT · alfredoperez/speckit-companion

Similar subagents

All subagents for Git and GitHub →

From the same set83

The whole set →
speckit.implement The speckit.implement prompt turns the plan in tasks.md into an ordered implementation run. It is listed for Claude Code and Codex. CX Codex GP ChatGPT ★ 110repo stars publish-all publish-all releases all four project components at once: the spec-kit extension, VS Code extension, Claude Code mod, and Copilot canvas. Runs only if changes are ready and pass QA checks. CX Codex +1 ★ 110repo stars speckit.companion.doctor speckit.companion.doctor audits spec run health by catching incomplete steps, unverified runs, and drift. Read-only, retroactive, and never halts on failures. CX Codex +1 ★ 110repo stars speckit.plan The speckit.plan subagent turns a feature specification into research and design artifacts. Use it when you’re ready to plan implementation. CX Codex +1 ★ 110repo stars submit-catalog-update submit-catalog-update is a Claude Code skill that generates and files an Extension Submission issue for the companion extension in spec-kit. It is used for minor and major version updates. CX Codex +1 ★ 110repo stars feature-clip feature-clip builds SpecKit Companion looping clips through capture, composition, rendering, and media sync for the site and documentation. CX Codex +1 ★ 110repo stars publish-speckit-ext publish-speckit-ext — a command to publish the spec-kit extension to a GitHub release. Lets other developers install the extension via catalog without cloning the repository. CX Codex +1 ★ 110repo stars speckit.constitution speckit.constitution is a Claude Code subagent that creates and updates the project constitution at .specify/memory/constitution.md based on team principles. CX Codex +1 ★ 110repo stars

Project sponsors

Companies that keep this analytics open