Roadmap
Turn a product brief or research artifact into a phased delivery blueprint your agent can execute autonomously across sessions with plan, start, resume, and status modes.
Overview
Roadmap is a journey-wide agent skill that generates phased delivery roadmaps and autonomously executes them phase by phase—usable whenever a solo builder needs an executable build plan before and during a multi-session
Install
npx skills add https://github.com/jezweb/claude-skills --skill roadmapWhat is this skill?
- Four modes: plan (generate roadmap), start (begin executing), resume (continue), status (show progress)
- Delivery blueprint with concrete per-phase tasks ordered from first build through launch
- Autonomous multi-session execution with commits at milestones, deploy, test, and continue
- Inputs from deep-research brief or product brief under `.jez/artifacts/`
- Triggers on phrases like plan the build, resume the build, what phase are we on
- 4 execution modes: plan, start, resume, status
Adoption & trust: 707 installs on skills.sh; 841 GitHub stars; 2/3 security scanners passed (skills.sh audits).
What problem does it solve?
You have research or a brief but no ordered, session-spanning plan your coding agent can follow without losing context between phases.
Who is it for?
Major greenfield products, multi-week Claude Code builds, and teams that want milestone commits plus deploy/test between phases.
Skip if: Single-file fixes, tasks with an already-approved implementation plan in progress, or workflows outside Claude Code (compatibility is claude-code-only).
When should I use this skill?
User says roadmap, plan the build, start building, resume the build, keep going, build the whole thing, execute the roadmap, or what phase are we on.
What do I get? / Deliverables
You get a milestone-oriented roadmap and optional autonomous execution with status/resume until launch—or a clear stuck point to unblock.
- Phased technical roadmap file
- Phase execution progress via status mode
- Incremental commits at roadmap milestones
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Turn a deep-research brief into phased scope and ordered tasks before writing code.
Execute backend phases from the roadmap with milestone commits between integrations.
Pick up frontend phases in a new session using resume without re-explaining the whole product.
Run deploy-and-test steps defined in later roadmap phases before calling the build done.
Use status to see remaining phases when extending a shipped product with a new roadmap revision.
How it compares
Use instead of ad-hoc “build this” chat threads when you need a persisted phased blueprint and resume/status controls.
Common Questions / FAQ
Who is roadmap for?
Solo and indie builders shipping full products with Claude Code who need a delivery blueprint and long-running execution across many sessions.
When should I use roadmap?
Use it when starting a major product after deep research, converting a vague idea into tasks, planning a multi-week build, or when you need to plan the build, start building, resume the build, or check what phase you are on—including validate scoping and build-through-ship execut
Is roadmap safe to install?
The skill allows Read, Write, Edit, Glob, Grep, and Bash for autonomous builds; review the Security Audits panel on this page and restrict repo access before granting execution modes.
SKILL.md
READMESKILL.md - Roadmap
# Roadmap Generate a comprehensive technical roadmap for building an entire application. Detailed enough that Claude Code can pick up any phase and execute it autonomously for hours. This is not a high-level strategy doc. It's a **delivery blueprint** — every phase has concrete tasks, every task is actionable, and the whole thing is ordered so you can build from phase 1 through to launch without backtracking. ## When to Use - Starting a major new product (after deep-research, or from a product brief) - Converting a vague idea into an executable plan - Planning a multi-week build that will span many Claude Code sessions - Before saying "build this" — the roadmap is what you hand Claude Code to execute ## Inputs The skill needs one of these: | Input | Where to find it | |-------|-----------------| | Deep research brief | `.jez/artifacts/research-brief-{topic}.md` (from `/deep-research`) | | Product brief | User describes what they want to build | | Existing partial app | Read CLAUDE.md + codebase to understand what exists | | Competitor to clone/improve | URL or product name — skill analyses it | If the user just says "plan a note-taking app on Cloudflare", that's enough — ask clarifying questions as needed. ## Workflow ### 1. Establish the Vision Before any technical planning, nail down: - **One sentence**: What is this? ("A cloud-native markdown knowledge workspace for teams and AI agents") - **Who**: Primary users, secondary users, agents? ("Jez first, then Jezweb team, then clients") - **Why**: What existing tools fail at? What's the gap? ("Existing tools are headless — you can't browse them or stumble across things") - **Constraint**: Stack, budget, timeline, must-haves? ("Cloudflare, must have MCP, needs to be a PWA") - **Not building**: What's explicitly out of scope? ("No real-time CRDT collab, no plugin ecosystem") ### 2. Define the Stack Based on the vision and constraints, lock in the technical stack: ```markdown | Layer | Choice | Why | |-------|--------|-----| | Frontend | [framework] | [reason] | | Backend | [framework + runtime] | [reason] | | Database | [engine + ORM] | [reason] | | Auth | [provider] | [reason] | | Storage | [service] | [reason] | | Search | [method] | [reason] | | Hosting | [platform] | [reason] | ``` If a deep-research brief exists, pull the recommendations from there. If not, make opinionated choices based on the user's existing stack (check `~/Documents/` for patterns). ### 3. Design the Data Model Sketch all tables/collections the full product will need. Not just phase 1 — the complete model. This prevents schema redesigns mid-build. ```markdown ## Data Model ### [entity] id, [type] [field], [type], [constraints] ... created_at, updated_at ### [entity] ... ### Relationships - [entity] has many [entity] via [field] - [entity] belongs to [entity] via [field] ``` Mark which tables are needed in which phase. Phase 1 might only need 3 of 8 tables, but designing them all upfront avoids migration pain. ### 4. Plan the Phases This is the core of the roadmap. Each phase must: - **Have a clear goal** — one sentence describing what's different when this phase is done - **Be independently deployable** — the app works (with reduced features) after each phase - **Build on the previous phase** — no phase requires ripping out what came before -