Skip to content
Skills Library
Management & product · Planning

dev10x:project-scope

/dev10x:project-scope

Scope a multi-ticket project with milestones, blocking relationships, and tracker integration. Accepts a parent ticket URL/ID or free-text description and creates the full project structure in Linear, JIRA, or GitHub Issues. TRIGGER when: scoping a multi-ticket project with milestones and blocking relationships. DO NOT TRIGGER when: scoping a single ticket (use dev10x:ticket-scope), or creating individual tickets (use dev10x:ticket-create).

Licence
MIT
Last repository change
12.10.2026

Assessment and security

90/ 100Class: good
Format15 / 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
6
Scripts
0
HTML comments
0
URLs in SKILL.md
3
Deprecation

No signals detected. Repository changed on 12.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

Scope a multi-ticket project with milestones, blocking relationships, and tracker integration. Accepts a parent ticket URL/ID or free-text description and creates the full project structure in Linear, JIRA, or GitHub Issues. TRIGGER when: scoping a multi-ticket project with milestones and blocking relationships. DO NOT TRIGGER when: scoping a single ticket (use dev10x:ticket-scope), or creating individual tickets (use dev10x:ticket-create).

Original author description

Scope a multi-ticket project with milestones, blocking relationships, and tracker integration. Accepts a parent ticket URL/ID or free-text description and creates the full project structure in Linear, JIRA, or GitHub Issues. TRIGGER when: scoping a multi-ticket project with milestones and blocking relationships. DO NOT TRIGGER when: scoping a single ticket (use dev10x:ticket-scope), or creating individual tickets (use dev10x:ticket-create).

How it works

  1. Overview
  2. Orchestration
  3. Input Classification
  4. Phase 1: Gather & Understand
  5. Phase 2: High-Level Scope
  6. Agent Delegation (Phases 3-4)
  7. Phase 3: Create Structure
  8. Phase 4: Verify & Report
  9. Error Handling
  10. Integration with Other Skills
Original SKILL.md headings · 380 lines, 2,128 words
SKILL.md preview
---
name: dev10x:project-scope
description: >
  Scope a multi-ticket project with milestones, blocking relationships,
  and tracker integration. Accepts a parent ticket URL/ID or free-text
  description and creates the full project structure in Linear, JIRA,
  or GitHub Issues.
  TRIGGER when: scoping a multi-ticket project with milestones and
  blocking relationships.
  DO NOT TRIGGER when: scoping a single ticket (use dev10x:ticket-scope),
  or creating individual tickets (use dev10x:ticket-create).
user-invocable: true
invocation-name: dev10x:project-scope
allowed-tools:
  - mcp__claude_ai_Linear__get_issue
  - mcp__claude_ai_Linear__save_issue
  - mcp__claude_ai_Linear__save_project
  - mcp__claude_ai_Linear__get_project
  - mcp__claude_ai_Linear__list_projects
  - mcp__claude_ai_Linear__save_milestone
  - mcp__claude_ai_Linear__list_milestones
  - mcp__claude_ai_Linear__list_issue_statuses
  - Bash(${CLAUDE_PLUGIN_ROOT}/skills/gh-context/scripts/:*)
  - Bash(gh label create:*)
  - Bash(/tmp/Dev10x/bin/mktmp.sh:*)
  - Skill(dev10x:ticket-create)
  - Skill(dev10x:estimate)
  - mcp__plugin_dev10x_cli__detect_tracker
  - mcp__plugin_dev10x_cli__milestone_create
  - mcp__plugin_dev10x_cli__milestones_bulk_create
  - mcp__plugin_dev10x_cli__issue_create
  - mcp__plugin_dev10x_cli__issue_edit
  - mcp__plugin_dev10x_cli__issue_comment
  - mcp__plugin_dev10x_cli__issue_list
  - mcp__plugin_dev10x_cli__issues_bulk_create
  - mcp__plugin_dev10x_cli__issues_bulk_edit
---

# Project Scope - Multi-Ticket Project Creation

## Overview

This skill orchestrates multi-ticket project creation with milestones
and blocking relationships. It takes a parent ticket or free-text
description and produces a complete project structure in the tracker.

**Use when:**
- Scoping a feature that spans multiple tickets and milestones
- Breaking down an epic or ADR into implementation phases
- Creating a project with blocking chains between tickets

**Do NOT use for:**
- Single-ticket scoping (use `dev10x:ticket-scope`)
- Architectural decisions without implementation tickets (use `dev10x:adr`)
- Creating a single ticket (use `dev10x:ticket-create`)

## Orchestration

This skill follows `references/task-orchestration.md` patterns
(Tier: Standard).

**Auto-advance:** Complete each phase and immediately start the next — no checkpoints the resolver did not ask for.
Never pause between phases to ask "should I continue?".

**REQUIRED: Create tasks before ANY work.** Execute these
`TaskCreate` calls at startup:

1. `TaskCreate(subject="Gather & understand input", activeForm="Gathering context")`
2. `TaskCreate(subject="Scope project structure", activeForm="Scoping project")`
3. `TaskCreate(subject="Create tracker structure", activeForm="Creating structure")`
4. `TaskCreate(subject="Verify & report results", activeForm="Verifying entities")`

Set sequential dependencies: scope blocked by gather, create blocked
by scope, verify blocked by create.

## Input Classification

| Input | Type | Behavior |
|-------|------|----------|
| `PAY-662` or `JIRA-123` | Ticket ID | Call `detect_tracker` MCP tool, fetch as parent |
| `https://linear.app/.../issue/XXX-N/...` | Linear URL | Extract ID, fetch as parent |
| `https://*.atlassian.net/browse/XX-N` | JIRA URL | Extract ID, fetch as parent |
| `https://github.com/.../issues/N` | GitHub URL | Extract repo + number, fetch as parent |
| Free text description | New project | Create parent ticket first |

## Phase 1: Gather & Understand

### 1.1 Classify Input

Determine whether the user provided a ticket reference or free text.

### 1.2 Fetch Context

**If ticket reference:** Fetch ticket details (title, description,
comments, labels, related tickets) via Linear MCP or GitHub CLI.

**If free text:** Store as project description for Phase 2.

### 1.3 Detect Tracker

Call `mcp__plugin_dev10x_cli__detect_tracker(ticket_id="$TICKET_ID")`
to determine the project's tracker backend.

**REQUIRED: Call `AskUserQuestion`** (do NOT use plain text, call spec: [ask-tracker-selection.md](./tool-calls/ask-tracker-selection.md)) when
tracker cannot be detected automatically (e.g., free-text input
with no branch context). Options:
- Linear (Recommended) — Create Linear project with milestones
- JIRA — Create JIRA epic with sub-tasks
- GitHub Issues — Create milestones and issues via `gh` CLI

### 1.4 Research Codebase

If the project involves code changes, explore the codebase for
relevant patterns, existing components, and architectural context.

## Phase 2: High-Level Scope

### 2.1 Produce Scope Document

Generate the following sections:

1. **Executive summary** — 1-2 paragraphs describing the project goal
   and approach
2. **Milestones** — named by outcome, with goals and dependencies
   (see Milestone rules below)
3. **Tickets per milestone** — title, 1-2 sentence description,
   priority, estimated complexity — **only for startable work**
   (see Ticket gating below)
4. **Blocking chain** — which tickets block which and why
5. **Estimate** — **REQUIRED: Call `Skill(dev10x:estimate)`** with
   the created tickets and the blocking chain. Each ticket's
   "estimated complexity" is the skill's points plus the elapsed
   range. The project roll-up follows the skill's § Project-level
   estimates, with effort and elapsed reported per milestone
   (GH-1495). **Roll up only tickets that will be created.** A
   milestone with no tickets gets an indicative range, labelled
   provisional, and stays out of the totals — a sum that mixes
   scoped tickets with guesses reads as a commitment nobody made.

Tickets are intentionally high-level. Further refinement via
`dev10x:ticket-scope` is expected for individual tickets.

**Milestone rules (GH-1509):**

- **No ordinal prefixes.** Never name a milestone `M0 …`,
  `Phase 2 …`, or `1. …`. Numbers in names make milestones hard to
  split or merge: every later title has to be renamed. Name each
  milestone by its outcome.
- **Ordering is a dependency, not a number.** Each milestone's
  description carries a `Depends on: <milestone name>` line, and
  tickets carry `blocks` / `blockedBy`.
- Descriptions follow
  [`references/milestone-description.md`](references/milestone-description.md).
- A namespace or initiative prefix is fine; a sequence number after
  it is not. The rule forbids encoding *sequence* in a name, not
  namespacing.

**Ticket gating (GH-1509):** Create tickets only for work that is
fully known and can start now, in sequence or in parallel.

- A milestone that sits behind a spike, investigation, or go/no-go
  decision gets **no tickets**. Its description carries a summary,
  code references, open questions, and a "how to scope this
  milestone" guide, per the reference above. Ticket creation for it
  is left to a later refinement session.
- **A go/no-go spike decides the downstream milestones too.** Its
  acceptance criteria must include deciding the fate of each
  milestone that depends on it — keep, reshape, or drop — not only
  whether the approach is viable.

Ticketing work that a spike can still reshape produces tickets that
are rewritten or closed after the spike, and an estimate that counts
them.

### 2.2 Present for Approval

**REQUIRED: Call `AskUserQuestion`** (do NOT use plain text, call spec: [ask-scope-approval.md](./tool-calls/ask-scope-approval.md)).
This blocks execution until the user responds. Options:
- Approve (Recommended) — Create all milestones, and tickets for startable work, as shown
- Revise — I have corrections to the structure
- More research needed — Need to explore additional areas

If "Revise": incorporate feedback and re-present.
If "More research": return to Phase 1.4 with user guidance.

## Agent Delegation (Phases 3-4)

**REQUIRED:** Delegate Phases 3 and 4 to a single background
haiku agent. Raw tracker API responses consume ~26k tokens for
a 6-issue project — the agent absorbs them and returns only a
compact summary.

**Dispatch after Phase 2 approval:**

1. Compose the agent prompt with:
   - Tracker type and configuration (team UUID, project UUID)
   - The full approved scope (milestones with their descriptions,
     tickets, blocking chain)
   - Creation instructions from Phase 3 below
   - Verification instructions from Phase 4 below

2. Dispatch:

```
Agent(
    subagent_type="general-purpose",
    model="haiku",
    description="Create {tracker} structure for {project}",
    prompt="<composed from approved scope + Phase 3-4 instructions>",
    run_in_background=true
)
```

3. When the agent completes, present its compact summary to the
   user. The main session never sees raw API response bodies.

**Agent return format (include verbatim in the prompt):**

```
Return ONLY a compact summary (max 200 words):
- Parent ticket: ID + URL
- Project entity: ID + URL (or "skipped")
- Per milestone: name → ID
- Per ticket: ID → URL → milestone
- Blocking chain: confirmed/failed pairs
- Failures: entity + reason + remediation
Do NOT return full API response bodies or descriptions.
```

Phases 3 and 4 below describe what the agent executes — include
the relevant instructions in the agent's prompt.

---

## Phase 3: Create Structure

### 3.1 Tracker Dispatch

| Operation | Linear | JIRA | GitHub Issues |
|-----------|--------|------|---------------|
| Create project | `save_project` (optional) | Epic via `dev10x:jira` | N/A (use milestones) |
| Create milestone | `save_milestone` | Sprint/Fix Version via `dev10x:jira` | `mcp__plugin_dev10x_cli__milestone_create` (single) / `milestones_bulk_create` (batch) |
| Create label | (via `save_issue`) | (via `dev10x:jira`) | `gh label create` |
| Create ticket | `save_issue` + milestone + project | via `dev10x:jira` | `mcp__plugin_dev10x_cli__issue_create` (single) / `issues_bulk_create` (batch) |
| Edit ticket | `save_issue` (upsert) | via `dev10x:jira` | `mcp__plugin_dev10x_cli__issue_edit` / `issues_bulk_edit` (batch) |
| Set blocking | `save_issue` blockedBy/blocks | Link via `dev10x:jira` | `mcp__plugin_dev10x_cli__issue_comment` cross-reference (no native blocking) |

GitHub Issues operations route through MCP wrappers — raw `gh issue
edit`, `gh issue comment`, `gh api .../milestones POST`, and `gh
issue create` are blocked by the skill-redirect hook. The MCP path
avoids per-invocation permission prompts and returns structured
responses.

### 3.2 Create/Resolve Parent Ticket

**If free text:** Invoke `Skill(skill="dev10x:ticket-create")` to
create the parent ticket using the executive summary as description.

**If ticket reference:** Use the fetched ticket as parent.

### 3.3 Create Project Entity

**When the planned milestones require a project entity, create it —
do not ask.** That is Linear with milestones: Linear milestones belong
to a project, so offering "Skip" would offer a structure that cannot
be created.

**Otherwise — REQUIRED: Call `AskUserQuestion`** (do NOT use plain
text, call spec: [ask-project-entity.md](./tool-calls/ask-project-entity.md))
— JIRA and GitHub Issues with or without milestones, and Linear with
no milestones planned. This blocks execution until the user responds.
Options:
- Create project entity (Recommended) — Enables roadmap views and project tracking
- Skip — No project entity; milestones (if any) and tickets only

**After creating or selecting a project**, resolve its UUID
immediately via `list_projects(team: "TEAM_UUID")` and store
it for all subsequent calls. Never pass a project name or slug
to `save_issue` — name matching is exact and fails silently.
See `dev10x:linear` § Project Assignment for the full pattern.

### 3.4 Create Milestones

Check for existing milestones by name before creating to avoid
duplicates — call `mcp__plugin_dev10x_cli__issue_list` with a
`milestone:` filter, or query directly via the tracker API.

Create every approved milestone, including those with no tickets.
Pass the description built from
[`references/milestone-description.md`](references/milestone-description.md),
with its `Depends on:` line, so the ordering survives in the tracker.

**GitHub Issues:** Call `mcp__plugin_dev10x_cli__milestones_bulk_create`
once with the full list. The wrapper iterates `milestone_create`
per entry and returns `{created: [...], failed: [...]}`. Failed
entries do not abort the batch — inspect `failed` for duplicates
or validation errors and address them before proceeding to 3.5.

For one or two milestones, prefer the single-entry tool
`mcp__plugin_dev10x_cli__milestone_create` to keep payloads simple.

### 3.5 Create Tickets

Create all tickets with milestone and project assignments.
Use the project UUID resolved in 3.3 — never pass a display name.
Check for existing tickets by title before creating.

**GitHub Issues batch pattern (10+ issues):**

1. Write each ticket body to a temp file via the Write tool. Keep
   the file as **clean Markdown only** — no metadata header. Use
   `mcp__plugin_dev10x_cli__mktmp` to allocate the path:
   `mktmp(namespace="gh-issues", prefix="NNN-slug", ext=".md")`.
2. Build the `issues` payload as a list of dicts:
   ```python
   issues = [
     {
       "title": "Ticket title here",
       "body": Read("<path-from-mktmp>"),  # body content from step 1
       "milestone": "Milestone Name",
       "labels": ["enhancement", "area/payments"],
     },
     # ... one entry per ticket
   ]
   ```
3. Call `mcp__plugin_dev10x_cli__issues_bulk_create(issues=issues)`
   in a single tool call. The wrapper returns
   `{created: [{number, url, title}, ...], failed: [...]}`. The
   batch does not abort on individual failures — inspect `failed`
   and retry per-entry as needed.

A single bulk call replaces N per-ticket `gh issue create`
invocations and removes the per-invocation permission prompts
that the loop pattern produced.

For one or two tickets, prefer `mcp__plugin_dev10x_cli__issue_create`
directly.

**Batch edits:** When the same field needs to change across many
tickets (e.g., reassigning milestone after the project has
re-shaped), build an `edits` list and call
`mcp__plugin_dev10x_cli__issues_bulk_edit` once. Each entry
requires `number` plus at least one of `title`, `body`,
`milestone`, `labels`.

**If raw `gh` is needed as fallback** (e.g., MCP server
unavailable): write bodies to temp files via Write tool, then
`gh issue create --body-file ...`. Watch for these friction
sources — they exist for raw `gh` only:

- Command substitution: `gh issue edit --body "$(gh issue view ...)"`
  breaks allow-rule prefix matching. Write to a temp file first.
- Env-var prefix: `REPO="owner/repo" gh issue create ...` shifts
  the command prefix. Use `--repo owner/repo` inline.

### 3.6 Set Blocking Relationships

Set blocking/blocked-by relationships between tickets per the
approved blocking chain. On GitHub Issues, blocking is conveyed
via cross-reference comments — call
`mcp__plugin_dev10x_cli__issue_comment(number, body)` per
relationship. Execute in parallel since all tickets exist.

### 3.7 Link Tickets to Project

Link all tickets to the project entity (if created in 3.3).
Execute in parallel.

## Phase 4: Verify & Report

### 4.1 Re-Fetch and Verify Linkage

Re-fetch all created entities to verify:
- Milestones are assigned correctly
- Blocking chains are intact
- Project links are set — for each ticket, call
  `get_issue(id)` and confirm `projectId` matches the
  expected UUID. Report any mismatches as failures in 4.3.

### 4.2 Structured Summary

Present a summary with:
- Parent ticket link
- Project entity link (if created)
- Milestone list with ticket counts and `Depends on:` lines;
  milestones with no tickets yet are marked provisional
- Blocking chain visualization
- Links to all created tickets

### 4.3 Failure Reporting

Report any failures with:
- Which entity failed and why
- What succeeded (no rollback)
- Suggested manual remediation steps

## Error Handling

| Scenario | Behavior |
|----------|----------|
| API failure | Retry once, then report with failed entity details |
| Partial creation | Report what succeeded, do not roll back |
| Duplicate detected | Skip creation, use existing entity, log warning |
| Relationship failure | Log and continue with remaining relationships |

## Integration with Other Skills

| Trigger | Skill | Direction |
|---------|-------|-----------|
| Free-text needs parent ticket | `dev10x:ticket-create` | Delegates to |
| Parent needs Job Story | `dev10x:jtbd` | Delegates to (optional) |
| User refines a child ticket | `dev10x:ticket-scope` | User invokes manually |
| User starts work on a ticket | `dev10x:work-on` | User invokes manually |

Child tickets are NOT auto-scoped via `dev10x:ticket-scope`.
High-level fidelity is intentional.
Files in this package (6)
  • SKILL.md 16 KB
  • evals/evals.json 4 KB
  • references/milestone-description.md 3 KB
  • tool-calls/ask-project-entity.md 1 KB
  • tool-calls/ask-scope-approval.md 1 KB
  • tool-calls/ask-tracker-selection.md 1 KB

Versions

The database has no other skills named dev10x:project-scope.

Database snapshot: 13.11.2026 · package version 8889a6bb4a85 (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

  • 90dev10x:ticket-create
    Create an issue tracker ticket (GitHub issue, Linear, or JIRA) with proper formatting, description structure, and labels. Accepts title, description content, and optional labels. Automatically formats the description with Root Cause, Solution, and Files Changed sections. Returns…
  • 90tracker
    Read, create and update tickets in whichever tracker the project uses (Linear, Jira, ClickUp, GitHub Issues, markdown files, or a custom one). Use whenever a task involves a ticket: reading its scope, creating one, moving its status, commenting. Never call tracker tools directly.
  • 90dev10x:linear
    Linear issue tracker operations via MCP tools. Get, create, update issues and list comments. Documentation-only skill — no scripts. TRIGGER when: performing CRUD operations on Linear issues, comments, or statuses. DO NOT TRIGGER when: using GitHub Issues or JIRA (use…
  • 100project-manager
    Use this skill for ANY interaction with external issue tracking and project management tools (Linear, Jira, GitHub Issues, etc.). This includes: - Reading, creating, or updating issues in Linear/Jira/GitHub - Querying project boards, backlogs, or sprints - Updating issue…
  • 90using-tracker
    Use when the user mentions issues, tickets, tasks, epics, current work, sprint or cycle, backlog, creating or updating issues, or anything about task tracking and planning in any tracker (Linear, Jira, GitHub Issues, local files). Invoke BEFORE asking the user any question about…
  • 100writing-tickets
    Write or rewrite an issue tracker ticket (Linear, GitHub Issues, Jira, or similar) that a person or coding agent will pick up. States the objective, evidence, decisions already made, hard rules, and done criteria, and leaves the how to the implementer. Use when the user says…

Feedback and reports

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