Agile Product Owner
alirezarezvani/claude-skills
Writes INVEST-checked user stories with acceptance criteria, splits epics, plans sprints from velocity and ranks the backlog with a weighted score.
Agent skill
Walking Skeleton Roadmap Scoping
by prime-radiant-inc in prime-radiant-inc/iterative-development
Turns extracted requirements into a roadmap by choosing a walking skeleton iteration with its first journey scenario and ordering the remaining work into follow-on iterations.
Install Walking Skeleton Roadmap Scoping
$ npx skills add prime-radiant-inc/iterative-development --skill scoping-the-simplest-core -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install prime-radiant-inc/iterative-development scoping-the-simplest-core --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/prime-radiant-inc/iterative-development.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/scoping-the-simplest-core .claude/skills/scoping-the-simplest-core && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "scoping-the-simplest-core" agent skill from https://github.com/prime-radiant-inc/iterative-development/tree/main/skills/scoping-the-simplest-core into .claude/skills/scoping-the-simplest-core/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "scoping-the-simplest-core", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/prime-radiant-inc/iterative-development/tree/main/skills/scoping-the-simplest-coreType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add prime-radiant-inc/iterative-development --skill scoping-the-simplest-core -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install prime-radiant-inc/iterative-development scoping-the-simplest-core --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/prime-radiant-inc/iterative-development.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/scoping-the-simplest-core .agents/skills/scoping-the-simplest-core && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "scoping-the-simplest-core" agent skill from https://github.com/prime-radiant-inc/iterative-development/tree/main/skills/scoping-the-simplest-core into .agents/skills/scoping-the-simplest-core/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "scoping-the-simplest-core", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add prime-radiant-inc/iterative-development --skill scoping-the-simplest-core -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install prime-radiant-inc/iterative-development scoping-the-simplest-core --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/prime-radiant-inc/iterative-development.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/scoping-the-simplest-core .cursor/skills/scoping-the-simplest-core && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "scoping-the-simplest-core" agent skill from https://github.com/prime-radiant-inc/iterative-development/tree/main/skills/scoping-the-simplest-core into .cursor/skills/scoping-the-simplest-core/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "scoping-the-simplest-core", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/prime-radiant-inc/iterative-development.git --path skills/scoping-the-simplest-core--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add prime-radiant-inc/iterative-development --skill scoping-the-simplest-core -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install prime-radiant-inc/iterative-development scoping-the-simplest-core --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/prime-radiant-inc/iterative-development.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/scoping-the-simplest-core .gemini/skills/scoping-the-simplest-core && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "scoping-the-simplest-core" agent skill from https://github.com/prime-radiant-inc/iterative-development/tree/main/skills/scoping-the-simplest-core into .gemini/skills/scoping-the-simplest-core/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "scoping-the-simplest-core", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install prime-radiant-inc/iterative-development scoping-the-simplest-coreInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add prime-radiant-inc/iterative-development --skill scoping-the-simplest-core -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/prime-radiant-inc/iterative-development.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/scoping-the-simplest-core .github/skills/scoping-the-simplest-core && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "scoping-the-simplest-core" agent skill from https://github.com/prime-radiant-inc/iterative-development/tree/main/skills/scoping-the-simplest-core into .github/skills/scoping-the-simplest-core/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "scoping-the-simplest-core", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add prime-radiant-inc/iterative-development --skill scoping-the-simplest-core -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install prime-radiant-inc/iterative-development scoping-the-simplest-core --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/prime-radiant-inc/iterative-development.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/scoping-the-simplest-core .opencode/skills/scoping-the-simplest-core && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "scoping-the-simplest-core" agent skill from https://github.com/prime-radiant-inc/iterative-development/tree/main/skills/scoping-the-simplest-core into .opencode/skills/scoping-the-simplest-core/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "scoping-the-simplest-core", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Facts
- Skill name
scoping-the-simplest-core- GitHub stars
- 181
- Token cost
- ~1.7k tokens
- SKILL.md length
- 693 words
- Files
- 3 (incl. scripts)
- Skills in repo
- 6
- Repo updated
- First seen
- Licence
- Apache-2.0
At a glance
Turns extracted requirements into a roadmap by choosing a walking skeleton iteration with its first journey scenario and ordering the remaining work into follow-on iterations.
- Works in 7 steps: Read the backlog → Define the walking skeleton (ITER-0000) → Order remaining stories into iterations → …
- Turning a requirements backlog into an ordered iteration roadmap
- SKILL.md covers Overview, When to Use, Script Location and Scoping Process, plus 2 more sections
- Runs Python scripts from its folder; calls git and python3
What it does
The skill reads the per-epic requirement files and behavior-scenarios.md under docs/superpowers/iterations and writes roadmap.md next to them: an ITER-0000 walking skeleton followed by ordered iterations. It runs after the extracting-requirements step during bootstrap of the iterative-development workflow, and it has a citation and scope review done through PAR before the roadmap is committed. Bundled scripts check_citations.py and validate_roadmap.py support that review.
The walking skeleton takes a small cohesive set of stories from as many distinct epics as possible and must close at least one journey scenario chain, preferably the core product journey, so that scenario is runnable as an automated or scripted test. It also yields the first stable scenario IDs, the first executable behavior harness and a small sentinel corpus that is rerun every iteration. Building the end-to-end harness is its first task, before any product feature. Story splitting applies when acceptance criteria have different dependency profiles.
When your agent uses it
- Turning a requirements backlog into an ordered iteration roadmap
- Choosing the smallest set of stories that proves the product works end to end
- Splitting a story whose acceptance criteria depend on different work
Example prompts
- “Build the roadmap from the requirements in docs/superpowers/iterations/requirements.”
- “Pick the walking skeleton and tell me which journey scenario it must close.”
- “Split the story whose acceptance criteria depend on different work, then reorder the iterations.”
- “Validate the roadmap and check its citations.”
Requirements
- Requirement files produced by the extracting-requirements step
- Python, to run the roadmap and citation check scripts
Workflow steps
7 steps, taken from the step headings in SKILL.md.
What it can do on your machine
Read from SKILL.md and the folder at commit c05889a. It shows what the files ask for, not the result of running them.
Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
Ships 2 files in scripts/ (Python), which the agent can run.
Shell commands in SKILL.md call:
gitpython3
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Context cost
Walking Skeleton Roadmap Scoping loads about 1.7k tokens when it runs. Until then it costs about 69 tokens; SKILL.md has 693 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
Safety
Auto-check passed
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.
SKILL.md
The full file from prime-radiant-inc/iterative-development at commit c05889a, republished under its Apache-2.0 licence (© prime-radiant-inc). 693 words, ~1,666 tokens.
Download SKILL.mdSave it as
.claude/skills/scoping-the-simplest-core/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.- name
- scoping-the-simplest-core
- description
- Use when turning extracted requirements into a roadmap — selects the walking skeleton iteration with its first journey scenario, orders remaining work into follow-on iterations, and applies story splitting when ACs have different dependency profiles.
Scoping the Simplest Core
Overview
Reads the per-epic requirement files in docs/superpowers/iterations/requirements/ and docs/superpowers/iterations/behavior-scenarios.md, and produces docs/superpowers/iterations/roadmap.md: a walking-skeleton iteration (ITER-0000) plus ordered follow-on iterations. The walking skeleton must produce the first runnable journey scenario. Runs citation and scope review via PAR before committing the roadmap.
When to Use
Invoked by iterative-development during bootstrap after extracting-requirements.
Script Location
All scripts referenced below live in this skill's scripts/ directory, next to this SKILL.md file.
Scoping Process
1. Read the backlog
Read the epic files in docs/superpowers/iterations/requirements/ — scan epic headers and story titles first, then dip into specific epic files for ACs when selecting.
Also read docs/superpowers/iterations/behavior-scenarios.md to understand which scenarios exist and which stories they cover.
2. Define the walking skeleton (ITER-0000)
Select a small cohesive set of stories from as many distinct epics as possible. The walking skeleton should prove the end-to-end shape of the product works.
Scenario requirement: the walking skeleton MUST include stories that close at least ONE journey scenario chain. Prefer the core product journey (e.g., "normal dictation" over "debug investigation"). The skeleton is not done until that journey scenario is runnable as an automated or scripted-reproducible test.
The walking skeleton must also produce:
- The first stable scenario IDs
- The first executable behavior harness (the E2E test infrastructure)
- A small sentinel corpus that can be rerun every iteration
Harness-first task: The walking skeleton's FIRST task should be designing and building the E2E test harness — before implementing any product features. Use the test infrastructure checklist in skills/shared/behavior-evidence-formats.md to guide the design. Document the harness design decisions in the project's docs. The harness is a first-class deliverable, not an afterthought — every subsequent iteration extends it.
Selection rule: "if someone ran just these stories, they should see a demo that proves the product exists AND have at least one passing journey scenario that proves the demo works."
3. Order remaining stories into iterations
Each iteration is a sprint's worth of cohesive work. Iteration granularity is judgment-based — no hardcoded story count.
Story splitting rule: when assigning stories to iterations, check each story's ACs for dependency profiles. If a story has ACs where:
- Some ACs can be satisfied in iteration N (their dependencies exist)
- Other ACs require subsystems from iteration N+M (their dependencies don't exist yet)
Then SPLIT the story:
- Create a version with only the satisfiable ACs for iteration N
- Create a version with the remaining ACs for iteration N+M
- Update the requirements index with both versions (append
a/bto the story ID) - Update scenario refs in both versions
Why this matters: moving a whole story to a later iteration because one AC has a late dependency causes the other ACs to be re-interpreted through the receiving iteration's theme, and they get silently dropped.
Show full SKILL.md (236 more words)Show less
4. Run citation check
Run: python3 "scripts/check_citations.py" docs/superpowers/iterations/roadmap.md docs/superpowers/iterations/requirements/
Every iteration must cite only valid STORY-IDs from the index.
5. Scope review via PAR
Following skills/shared/parallel-adversarial-review.md:
- Build scope reviewer prompts using
skills/running-an-iteration/scope-reviewer-prompt.md - Wrap in PAR competitive framing
- Dispatch paired scope reviewers focused on:
- Is ITER-0000 really the thinnest possible walking skeleton?
- Does ITER-0000 close at least one journey scenario?
- Could anything be deferred from ITER-0000 to a follow-on?
- Does ITER-0000's design box in any follow-on iteration?
- Are any stories over-broad (mixing skeleton-level concerns with later integrations)?
- Are there stories with heterogeneous-dependency ACs that should be split?
- Does any iteration leave observable behavior without planned scenario coverage?
- If stories need splitting: apply the splitting rule from step 3, update requirements, re-scope.
- If REVISE recommended: adjust and re-review until APPROVE
6. Write and validate roadmap
Write the result to docs/superpowers/iterations/roadmap.md using this format:
# Roadmap
## Walking skeleton (ITER-0000)
**Intent:** <one-line description of the thinnest end-to-end slice>
**Design rationale:** <why these stories, what they prove together>
**Journey scenario:** <JOURNEY-NNNN that the skeleton must pass>
**Stories committed:**
- STORY-NNNN (EPIC-NNN)
- ...
**Status:** pending
## Iteration list
### ITER-0001 — <name>
**Stories:** STORY-NNNN, STORY-NNNN, ...
**Rationale:** <why these stories belong together>
**Status:** pending
**Impacted scenarios:** <SCENARIO-NNNN, JOURNEY-NNNN that this iteration touches>
**Look-ahead check:** <does this block or get blocked by neighbors?>Run: python3 "scripts/validate_roadmap.py" docs/superpowers/iterations/roadmap.md
Note: The validator checks format only. The PAR scope review is the real structural gate.
7. Commit
git add docs/superpowers/iterations/roadmap.md
git commit -m "docs: add roadmap — walking skeleton with journey scenario + iteration plan"Quick Reference
| Step | Tool/Skill | Purpose |
|---|---|---|
| Citation check | scripts/check_citations.py | All cited stories exist |
| Scope review | PAR + scope reviewer prompt | Walking skeleton minimal, journey scenario included, story splitting applied, no boxing-in |
| Story splitting | Manual (if PAR or dependency analysis finds heterogeneous ACs) | Split stories by dependency profile |
| Validate | scripts/validate_roadmap.py | Format check only |
References
skills/shared/parallel-adversarial-review.md— PAR methodologyskills/shared/behavior-evidence-formats.md— scenario and proof obligation formatsskills/running-an-iteration/scope-reviewer-prompt.md— scope reviewer prompt (reused)scripts/check_citations.py— mechanical citation check
© prime-radiant-inc, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Files
SKILL.md and 2 other files (scripts) in skills/scoping-the-simplest-core of prime-radiant-inc/iterative-development.
- SKILL.md
- scripts/check_citations.py
- scripts/validate_roadmap.py
Open the folder on GitHubat commit c05889a
Compare with similar skills
Walking Skeleton Roadmap Scoping next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Walking Skeleton Roadmap Scoping this skillprime-radiant-inc/iterative-development | 181 | — | ~1.7k | Automated safety check: Pass | Apache-2.0 | |
| Agile Product Owneralirezarezvani/claude-skills | 28k | 3 repos | ~3.2k | Automated safety check: Pass | MIT | |
| Epic Breakdown Advisordeanpeters/Product-Manager-Skills | 7.2k | 1 repos | ~6k | Automated safety check: Pass | Custom licence | |
| Bmad Sprint Planningdelorenj/mcp-server-trello | 445 | 5 repos | ~3k | Automated safety check: Pass | MIT | |
| Agile Product Ownerdavila7/claude-code-templates | 33k | 2 repos | ~256 | Automated safety check: Pass | MIT | |
| Bmad Sprint Planningaj-geddes/claude-code-bmad-skills | 488 | — | ~2k | Automated safety check: Notes | Custom licence |
Similar skills
Epic Breakdown Advisor
deanpeters/Product-Manager-Skills
Splits a too-large epic into user stories using Richard Lawrence's nine Humanizing Work splitting patterns while keeping each story a vertical slice of user value.
Bmad Sprint Planning
delorenj/mcp-server-trello
Generate sprint status tracking from epics. An agent skill from delorenj/mcp-server-trello.
Agile Product Owner
davila7/claude-code-templates
Agile product ownership toolkit for Senior Product Owner including INVEST-compliant user story generation, sprint planning, backlog management, and velocity tracking.
Bmad Sprint Planning
aj-geddes/claude-code-bmad-skills
Orchestration handoff bridge: emits and maintains sprint-status.yaml as the project's sequencing system-of-record.
Building Product
GTM-Strategist/gtm-strategist-skills
A skill your agent uses when the user needs to define their MVP, create a product roadmap, plan metrics and tracking, refine their value proposition with JTBD, or run usability tests.
More from prime-radiant-inc/iterative-development
Extracting Requirements
prime-radiant-inc/iterative-development
Reads human-written spec documents and produces per-epic requirement files with proof obligations plus behavior scenarios with stable IDs, using parallel chunked extraction.
Iterative Development Orchestrator
prime-radiant-inc/iterative-development
Runs an autonomous loop that extracts requirements with proof obligations, builds a walking skeleton, then audits sprint by sprint against real behavior evidence.
Running An Iteration
prime-radiant-inc/iterative-development
A skill your agent uses when executing the next pending iteration from an iterative-development roadmap — picks the iteration, decomposes into code and evidence tasks, runs sentinel corpus baseline…
Iteration Progress Audit
prime-radiant-inc/iterative-development
Checks the quality of behavior evidence after each iteration in three tiers, using two auditor subagents in parallel to review the same work and find gaps.
Implementing Tasks with Subagent Review
prime-radiant-inc/iterative-development
Runs a batch of TDD-sized tasks by dispatching an implementer subagent per task, followed by two-stage parallel adversarial review and fix loops.
Related
Categories
Questions about Walking Skeleton Roadmap Scoping
What does Walking Skeleton Roadmap Scoping do?
Turns extracted requirements into a roadmap by choosing a walking skeleton iteration with its first journey scenario and ordering the remaining work into follow-on iterations. md next to them: an ITER-0000 walking skeleton followed by ordered iterations. It runs after the extracting-requirements step during bootstrap of the iterative-development workflow, and it has a citation and scope review done through PAR before the roadmap is committed.
When should I use Walking Skeleton Roadmap Scoping?
Walking Skeleton Roadmap Scoping fits situations like: turning a requirements backlog into an ordered iteration roadmap; choosing the smallest set of stories that proves the product works end to end; splitting a story whose acceptance criteria depend on different work.
How do I install Walking Skeleton Roadmap Scoping in Claude Code?
Run `npx skills add prime-radiant-inc/iterative-development --skill scoping-the-simplest-core -a claude-code`. Or copy the skill folder (skills/scoping-the-simplest-core in prime-radiant-inc/iterative-development) into .claude/skills/scoping-the-simplest-core in your project. Claude Code loads it when a task matches its description.
How do I install Walking Skeleton Roadmap Scoping in Codex?
Run `npx skills add prime-radiant-inc/iterative-development --skill scoping-the-simplest-core -a codex`. Or copy the skill folder (skills/scoping-the-simplest-core in prime-radiant-inc/iterative-development) into .agents/skills/scoping-the-simplest-core in your project. Codex loads it when a task matches its description.
Can I use Walking Skeleton Roadmap Scoping in Cursor, Gemini CLI or GitHub Copilot?
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add prime-radiant-inc/iterative-development --skill scoping-the-simplest-core -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/scoping-the-simplest-core, .gemini/skills/scoping-the-simplest-core, .github/skills/scoping-the-simplest-core and .opencode/skills/scoping-the-simplest-core in your project.
What does Walking Skeleton Roadmap Scoping need to run?
Going by SKILL.md and its folder, Walking Skeleton Roadmap Scoping needs Python for the scripts in its folder and the command-line tools its instructions call (git and python3). Our summary lists: Requirement files produced by the extracting-requirements step; Python, to run the roadmap and citation check scripts.
Does Walking Skeleton Roadmap Scoping access the network?
SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.
Is Walking Skeleton Roadmap Scoping safe to install?
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.
What licence does Walking Skeleton Roadmap Scoping use?
Walking Skeleton Roadmap Scoping is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
How many tokens does Walking Skeleton Roadmap Scoping use?
About 1.7k tokens (SKILL.md is roughly 6.7k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.
What are the alternatives to Walking Skeleton Roadmap Scoping?
Skills that share tags, products or a category with Walking Skeleton Roadmap Scoping: Agile Product Owner (alirezarezvani/claude-skills, 28k stars), Epic Breakdown Advisor (deanpeters/Product-Manager-Skills, 7.2k stars), Bmad Sprint Planning (delorenj/mcp-server-trello, 445 stars) and Agile Product Owner (davila7/claude-code-templates, 33k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Walking Skeleton Roadmap Scoping?
prime-radiant-inc (a GitHub organization) maintains it in prime-radiant-inc/iterative-development, which has 181 GitHub stars. The repository holds 6 skills in this directory. The repository was last updated on June 6, 2026.
Source: prime-radiant-inc/iterative-development on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.