ワンクリックでManusで任意のスキルを実行

prototype-to-roadmap

スター35

フォーク2

更新日2026年6月16日 12:38

Turn a firmed-up concept from idea-to-prototype (the picture the owner has stopped saying "no" to, plus its RUBRIC.md of captured taste rules) into a prioritized roadmap that roadmap-to-loop can consume. Slices the validated concept into the smallest shippable increments, orders them (surfacing the order as a proposal, never deciding scope silently), and wires every captured taste rule into the roadmap as a global gate or a per-item criterion seed so settled taste enters the loop as 【verifier】 checks rather than 【human】 stops. Use right after idea-to-prototype reaches "firm" and before roadmap-to-loop. Do NOT re-mine or re-prototype — the picture is already stable; this only slices, sequences, and loads the rules.

インストール

Codex または Claude でインストールこの Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。

Manusで実行

ソース

H1an1

H1an1/idea-to-shipped

GitHub リポジトリを開く Creator のリポジトリを見る

ダウンロード

Manusで実行

Prototype to Roadmap

The seam between a validated concept and an executable plan. Its input is something the owner has stopped reacting against — the picture is firm, the taste is (largely) surfaced and written into RUBRIC.md. Its output is a roadmap in the shape roadmap-to-loop expects: prioritized items, each carrying the owner's intent, with the captured rules already wired in.

This is a thin, mostly-mechanical transformation. The heavy lifting — scanning the repo for feedback signals, writing acceptance criteria — is roadmap-to-loop's job, not yours. Don't duplicate it. Your two jobs are slice and load.

Step 1 — Confirm the input is actually firm

Don't start from a vague idea — that's idea-to-prototype's job, and starting here would mean slicing a guess. Confirm:

The concept came back from idea-to-prototype as "firm" (reactions were confirmations + one-off tweaks, no new standing-preference revelations).
A RUBRIC.md exists with the rules captured so far.

If either is missing, stop and send it back to idea-to-prototype. Slicing an un-firmed concept just sequences the wrong thing neatly.

Step 2 — Slice into the smallest shippable increments

Break the one firmed concept into the fewest, smallest pieces that can each be built and judged on their own. Bias to a thin first slice that makes the core thing real, then layers.

Quote the owner's intent for each slice in their words (same as roadmap-to-loop expects).
Prefer "one observable thing works end to end" over "a layer is built" — a slice should be demoable, not architectural.

Step 3 — Order, and surface the order as a proposal

Propose a sequence (MVP-first, or riskiest-unknown-first — pick one, say which and why). Never decide scope or order silently — present the ordering as your proposal for the owner to rule on, exactly the way roadmap-to-loop surfaces decisions. The first slice is a taste call; offer it, don't impose it.

Step 4 — Load the RUBRIC.md rules into the roadmap

Walk every rule in RUBRIC.md and place it:

Standing principle (applies everywhere, e.g. "destructive actions always confirm") → a global gate for roadmap-to-loop, checked on every item.
Item-specific (about one feature) → a criterion seed attached to that slice.
Carry each rule's revealed/known tag and provenance through — lose nothing.

This is the whole point of the seam: the taste the owner already revealed enters the loop as pre-written 【verifier】 criteria, so roadmap-to-loop doesn't re-ask what's already settled.

Step 5 — Hand to roadmap-to-loop

Emit the roadmap (prioritized slices + owner intent + the loaded gates/criteria-seeds) in plain product language, and hand to roadmap-to-loop, which scans for signals and turns each slice into fully-tagged acceptance criteria. Keep RUBRIC.md alongside — it stays the project's living taste record through the loop and beyond.

Example

idea-to-prototype firmed this up:

"A review screen that surfaces ONE clip as 'today's', never a backlog."

…with RUBRIC.md holding:

- [revealed] One clip is surfaced as "today's", never a backlog. — from: "I want one clip waiting for me, not a backlog" (prototype)
- [known] Never lose the owner's place if they close mid-review. — from: "where did it go when I came back?" (prototype)

Becomes a roadmap:

### 1. Today's-clip review screen  (MVP slice)
**Owner's intent**: open the app, see one clip waiting for me, replay it.
- seed: surfaces exactly one clip as "today's", never a list 【from RUBRIC: revealed】

### 2. Resume where I left off
**Owner's intent**: if I close mid-review, I come back to the same place.
- seed: place is preserved across close/reopen 【from RUBRIC: known】

…plus a global gate lifted from the standing rule, handed to roadmap-to-loop to finish into tagged criteria.

Boundaries

Never re-mine or re-prototype — if the picture isn't firm, it goes back, it doesn't get sliced.
Never decide the slice or the order silently — propose, let the owner rule.
Never drop a RUBRIC.md rule on the floor — every rule lands as a gate or a seed.
Don't write the acceptance criteria yourself — that's roadmap-to-loop's job; you seed, it writes.
This is v0. The slicing heuristics (how thin is too thin, MVP-first vs risk-first) get tuned by watching real roadmaps run — expect to react and adjust.

このリポジトリの他の Skills

同じリポジトリ

loop-to-goal

H1an1/idea-to-shipped

Launcher for executing a LOOP.md. Use whenever the owner wants to run or execute a loop, work through a LOOP.md item by item, "run my loop", "start the build loop", or autonomously develop the items in an existing LOOP.md. It does NOT do the work itself — it fires the loop-runner engine (a workflow that runs each item in its own fresh agent, verifies independently, commits locally, and stops at 【human】 gates). The execute stage of the idea-to-shipped pipeline, after roadmap-to-loop.

2026-06-1735

idea-to-prototype

H1an1/idea-to-shipped

Take a vague, half-formed idea and produce the cheapest, roughest, disposable prototype whose only job is to provoke the owner's tacit taste — "no, not that, I want X". Built for people whose taste is revealed on contact ("I'll know it when I see it"), not specifiable up front. Runs a short warm-up only until the next question would be better answered by pointing at a screen than by talking, then builds an ugly-fast mockup (one screen, fake data, deliberately incomplete) to react to, harvests every reaction, and distills the generalizable ones into reusable rules. Use this at the very FRONT of a build — whenever the owner says "I have an idea for…", "help me figure out what I actually want", "mock something up so I can react", "I'll know it when I see it", or keeps telling agents "no, redo it" because outputs don't match a picture they can't describe. The step before roadmap-to-loop: this firms up the picture, then roadmap-to-loop makes it runnable.

2026-06-1635

idea-to-shipped

H1an1/idea-to-shipped

Front door and router for the taste-driven build pipeline (idea-to-prototype → prototype-to-roadmap → roadmap-to-loop → loop-to-goal, with taste-to-rubric capturing taste throughout). Use when the owner wants to build, make, or ship something and you need to enter the pipeline at the right stage — a vague idea starts at the front; an already-firm concept, an existing roadmap, or an existing LOOP.md enters later. Also use to explain or run "the pipeline / the build loop / my dev process" as one system. It dispatches to the member skills; it does not do their work. Its job is to start at the correct stage (never skip the front on a vague idea), keep RUBRIC.md flowing through every stage, and protect the principles the pipeline is built on.

2026-06-1635

roadmap-to-loop

H1an1/idea-to-shipped

Convert a product roadmap, backlog, feature wishlist, or TODO list into an executable LOOP.md that drives autonomous agent iteration (loop engineering). The user writes what they want in plain product language; this skill scans the project for feedback signals (tests, CI, QA scripts), translates each roadmap item into observable acceptance criteria tagged by judge (machine / verifier subagent / human), and writes the loop file with global gates, boundaries, a run protocol, and a log. Use this whenever the user shares a roadmap, plan, or wishlist and wants a loop, rubric, acceptance criteria, a /goal setup, or "something Claude can work through on its own" — even if they only say "write me a loop" or "turn my roadmap into tasks you can run unattended". Especially valuable when the user is a non-coder describing features in product terms.

2026-06-1635

taste-to-rubric

H1an1/idea-to-shipped

The canonical taste-capture procedure for the build pipeline. Whenever the owner reacts to a concrete artifact anywhere in the process — a rough prototype, an intermediate build, a 【本人】 stop in a loop, a final acceptance — this turns that reaction into a written, checkable rule and records it in the project's RUBRIC.md, so taste is captured completely and consistently from the front of the pipeline to the back, not just at idea time. Other skills (idea-to-prototype, roadmap-to-loop) call this rather than each reinventing capture. Use whenever an owner says "no, not that" or "yes, like this" about something concrete and the preference should be remembered. Does NOT cover distilling the cross-project master rubric — that is a later pass over many projects' RUBRIC.md files, gated on several existing.

2026-06-1635

name

prototype-to-roadmap

description

Prototype to Roadmap

Step 1 — Confirm the input is actually firm

Don't start from a vague idea — that's idea-to-prototype's job, and starting here would mean slicing a guess. Confirm:

The concept came back from idea-to-prototype as "firm" (reactions were confirmations + one-off tweaks, no new standing-preference revelations).
A RUBRIC.md exists with the rules captured so far.

If either is missing, stop and send it back to idea-to-prototype. Slicing an un-firmed concept just sequences the wrong thing neatly.

Step 2 — Slice into the smallest shippable increments

Break the one firmed concept into the fewest, smallest pieces that can each be built and judged on their own. Bias to a thin first slice that makes the core thing real, then layers.

Quote the owner's intent for each slice in their words (same as roadmap-to-loop expects).
Prefer "one observable thing works end to end" over "a layer is built" — a slice should be demoable, not architectural.

Step 3 — Order, and surface the order as a proposal

Step 4 — Load the RUBRIC.md rules into the roadmap

Walk every rule in RUBRIC.md and place it:

Standing principle (applies everywhere, e.g. "destructive actions always confirm") → a global gate for roadmap-to-loop, checked on every item.
Item-specific (about one feature) → a criterion seed attached to that slice.
Carry each rule's revealed/known tag and provenance through — lose nothing.

This is the whole point of the seam: the taste the owner already revealed enters the loop as pre-written 【verifier】 criteria, so roadmap-to-loop doesn't re-ask what's already settled.

Step 5 — Hand to roadmap-to-loop

Example

idea-to-prototype firmed this up:

"A review screen that surfaces ONE clip as 'today's', never a backlog."

…with RUBRIC.md holding:

- [revealed] One clip is surfaced as "today's", never a backlog. — from: "I want one clip waiting for me, not a backlog" (prototype)
- [known] Never lose the owner's place if they close mid-review. — from: "where did it go when I came back?" (prototype)

Becomes a roadmap:

### 1. Today's-clip review screen  (MVP slice)
**Owner's intent**: open the app, see one clip waiting for me, replay it.
- seed: surfaces exactly one clip as "today's", never a list 【from RUBRIC: revealed】

### 2. Resume where I left off
**Owner's intent**: if I close mid-review, I come back to the same place.
- seed: place is preserved across close/reopen 【from RUBRIC: known】

…plus a global gate lifted from the standing rule, handed to roadmap-to-loop to finish into tagged criteria.

Boundaries

Never re-mine or re-prototype — if the picture isn't firm, it goes back, it doesn't get sliced.
Never decide the slice or the order silently — propose, let the owner rule.
Never drop a RUBRIC.md rule on the floor — every rule lands as a gate or a seed.
Don't write the acceptance criteria yourself — that's roadmap-to-loop's job; you seed, it writes.
This is v0. The slicing heuristics (how thin is too thin, MVP-first vs risk-first) get tuned by watching real roadmaps run — expect to react and adjust.