Recently, I built a development pipeline and wanted to share the thinking behind it. I was inspired by the whole loop/goal engineering and auto-goal (letting the agent write its own goals and spawn subtasks) lineage. But what really made it click was something about myself: my taste is the “I know it when I see it” type, not the “I can describe it” type. I can’t articulate what I want when asked coldly, but show me an ugly prototype and I instantly know what’s wrong.

So this pipeline works in reverse: first throw out an ugly prototype to provoke my reaction → write down each “no, I want…” as a checkable rule → turn those rules into acceptance criteria for the agent to develop one by one → and have each item independently verified by another agent that wasn’t involved in building it, so it can’t just declare itself done.

The alternative: you say “build me X”, the agent runs all the way to the end, and gives you something polished but not what you wanted — and you only find out at the most expensive moment (the end). This pipeline moves that “finding out it’s wrong” moment to the very beginning, when it’s cheapest, and never lets the agent cheat or deceive itself.

Both inspirations are worth reading: Lance Martin on how long-running agents slack off, get narcissistic, and drift off course; Addy Osmani on how to extract recurring corrections from a session into reusable rules.

http://github.com/H1an1/idea-to-shipped…

H1an1/idea-to-shipped

Source: https://github.com/H1an1/idea-to-shipped

idea-to-shipped

A taste-driven build pipeline for Claude Code — a package of six skills that take a half-formed idea all the way to a self-running build, without asking you to write a spec, and without losing the parts of “what you want” that you can only recognize once you see them. It’s built on one fact about how people actually work: your taste shows up when you react to something concrete, not when you’re asked to describe it in advance. So the pipeline never makes you specify everything up front. It makes you react, and it writes down what your reactions reveal.

Formerly roadmap-to-loop — that skill is now just one stage of the larger pipeline.

The pipeline

idea
↓
1. idea-to-prototype → an ugly, fast mock-up to react to. You say "no, not that"; it learns.
↓
2. prototype-to-roadmap → once the picture's firm, it slices it into a buildable, ordered plan.
↓
3. roadmap-to-loop → turns the plan into LOOP.md: what "done" means, and who checks it.
↓
4. loop-to-goal → the agent writes its own goals and builds, unattended, checking itself against your criteria, stopping only when it needs your eye.
↓
shipped
taste-to-rubric → runs underneath all of it. Every time you react to something — the first mock-up, a mid-build check, final sign-off — it captures the preference into RUBRIC.md so nobody has to ask you twice.
idea-to-shipped → the front door: it routes you to the right stage by what you already have, and protects the principles the pipeline is built on.

RUBRIC.md — your taste, written down

Each project grows one file, RUBRIC.md. Every “no, not that” that turns out to be a standing preference (not a one-off tweak) gets distilled into one checkable line, tagged revealed (you only knew it on sight) or known. Over a project it becomes the rulebook the agent checks itself against; rules graduate from “only the owner can judge” to “a verifier subagent can judge” over time. Over many projects, those rulebooks can be compared to distill the constants of your taste — but that’s later, once a few exist.

How to use it

You don’t pick a stage. Just say what you want — “I want something that…” — and the front door (idea-to-shipped) figures out where you are and starts you at the right place. A vague idea starts at the mock-up; if you already have a firm concept or a plan, it jumps in further down. Your job, start to end, is small and only yours: react (at the first mock-up) and judge (at the gates the agent stops you for). Everything in between is the machine’s.

Install

These are Claude Code (https://claude.com/claude-code) skills. Copy the ones you want into your personal skills directory:

git clone https://github.com/H1an1/idea-to-shipped.git
cp -R idea-to-shipped/skills/* ~/.claude/skills/

Each skill is a self-contained skills/<skill>/SKILL.md; its description controls when Claude reaches for it. You can also drop them into a project’s .claude/skills/ instead, to scope them to one repo.

The skills

What’s intentionally not built yet

• The cross-project master rubric (needs several projects’ RUBRIC.md to compare).
• Auto-loading rules back in / scoring — its shape will reveal itself once real rules pile up.

These come with mileage, not design. Run the pipeline on real things first; the next pieces will show you their shape.