craft

Craft

Stop Vibing. Start Crafting.

Install · Getting Started · Commands · How it works · What's New

Point at the page. Watch it change.

One comment sheet, built into three commands.

/craft:annotate on a real page, sped up. No file changes while you point.

/craft:annotate	/craft:mockup	/craft:dial
Turn on COMMENT MODE on the tab you have open. Each pin lands as a live change while you watch.	Every round of options arrives with the comment sheet aboard. Pin what you'd change, and the next round reloads in place.	Say you want to point, and the comment sheet joins the A, B, C, D panel. Each pin knows which letter was on screen.

Craft is a Claude Code plugin that asks you the product questions and works out the technical ones. Features get planned, built, and tested, with your codebase read-only until you approve the work. Point at a live page to change it. The calls you make - decisions, design tokens, the tweaks you loved - carry into every build after.

Claude's Write and Edit tools stay gated until you open a channel: a planned story, an investigated fix, a live tweak, or an approved one-off. Shell commands aren't gated - the gate covers Claude's file tools, not the terminal.

Install in about a minute:

claude plugin marketplace add drobins25/craft
claude plugin install craft@craft

Then start Claude Code and run /craft - full install notes.

A Write Gate, decision memory, and a taste engine for Claude Code

Write Gate	Decision memory
Write and Edit stay blocked on every project file until you open a story, an adhoc fix or tweak, the approve skill, or a workflow. Shell isn't gated - a workflow gate, not a sandbox.	Name the rulings a story carries in /craft:decisions; the planner reads them first. Waiving a locked decision always asks.
Taste engine	QA that files its own bugs
/craft:adhoc tweaks stamp loved or routine; three loved and craft offers to spread the look. Accepted mockups can become tokens - tokens and locks guide every mockup after.	/craft:analyze qa drives a real browser - clicks, forms, console. Confirmed and likely findings file into /craft:bugs; repeats add sightings.

Same Claude Code session. Less re-explaining what you already decided, more building on top of it.

It steals your best ideas back. You say "that's it!" after working through a tweak, and craft remembers. It waits, then brings that same taste back on a completely different feature - elevated. Keep going, and you'll catch yourself asking, "how did I do this?"

Craft building its own repo page, live.

Tip Don't want to read any of this? You don't have to.

Just say it to craft, in your own words:

"How can the craft guide agent help me solve this?"

The read-only guide agent auto-triggers on questions like that and answers from craft's actual source, not vibes. No command to memorize - though /craft:guide is there if you want to reach it on purpose.

Built with Craft

Craft has shipped real, public products across different domains - click through and see working software:

• darinbuilds.com - an immersive single-page portfolio and marketing site (Next.js, GSAP scroll), built across 30+ craft cycles.
• throve.fit - a structured daily coaching app: week-view programming, curated workouts with real coach's notes, exercise alternatives, and completion tracking.
• hirecalling.jobs - client work: a hiring platform where every job application triggers a verified, live-tracked donation to a nonprofit. Job searching that gives back.
• wodspark.com - where craft started: a free on-demand workout generator - pick a focus, equipment, and duration, and it builds a workout instantly.

Two of these are fitness apps, and they're genuinely different products - an instant generator versus a structured coaching tool. One is paid client work, shipped for someone else's business. That's the point: the same harness shipped range, not one idea four times.

What makes Craft different

Most Claude Code plugins ship a fixed set of helpers. Craft ships a workshop where you build your own - agents that argue from conviction, not a system prompt.

Craft's conductor is the AI-harness eagle eye craft itself is built under - every skill, agent, and hook in this repo was designed under its scrutiny. Ask it whether telling Claude "don't touch prod" actually protects you:

"You can, and it'll work about 95% of the time - which means it's guaranteed to fail on the exact run you can least afford it to. Instructions are guidance, not enforcement; a rule in your CLAUDE.md is a request the model can starve out under context pressure. If breaking this would actually hurt you, that's not a prompt - that's a hook. Exit code 2 blocks. A sentence just hopes."

That's not a system prompt. It's a crystallized practitioner. /craft:become studies a tool, role, or person and turns it into a portable agent that argues from scar tissue earned at 2 AM on run 50 - not read from docs.

And not just for code. Here's craft's muse, on why technically impressive features die:

I've watched enough launches fail - Google Wave, Fire Phone, Juicero, Google+, Facebook Home - to recognize the pattern before the metrics arrive. The pattern is always the same: the demo room loved it, the press loved it, users used it once and left. The thing that was missing was never functionality. It was always feeling.

Same machinery, different domain. You point /craft:become at the expertise you wish were in the room, and it crystallizes a mind you can consult - one with beliefs, refusals, and the scar tissue that makes its judgment worth trusting.

The Mockup Funnel

/craft:mockup is the fastest way to feel what craft is. Name something visual and ask:

"Can we create a craft mockup of the ecosystem cards?"

Three live HTML options open in your browser, at real scale, in real surrounding context. Stances, not variations: at most one may stay inside your current design language, and at least one has to go further than you asked. Three safe layouts in the current palette is a failed round.

You converge by reacting in plain words. No forms, no pickers.

• Diverge. Say which one pulls and what's wrong with the others. Hybrids are legal: "B with C's cards."
• Refine. Your pick becomes the base and comes back as variations of it.
• Polish. Micro-adjustments land in the open page while you watch. Try, see, keep or discard, seconds each.
• A feeling counts. "B is close but something's off" is a feeling, and craft riffs the fuzzy reaction into a sharp direction with you before rebuilding, instead of spending a round on a guess.
• Acceptance is explicit. "That's it, ship it." The new design values land in tokens.yaml with their provenance before anything downstream exists, so every later story and validator enforces the design you approved in your browser.
• Then it graduates on your call. Tweak it in now, grow it into a story with its CSS ported as-is, or park it as a notebook todo.

The same door takes a two-minute tweak:

"Tweak the rim around the Start button - gradient glow, maybe?"

/craft:adhoc makes the change in place, shows you, and records what you said. If the accepted values drift from your tokens or outgrow a lock, craft asks once, at acceptance, whether the new taste becomes the standard. Say yes and it offers a sweep to find the other surfaces that could inherit it.

And when the page is almost there, a notch off:

"Can we dial down the login text and try a different color perhaps?"

/craft:dial drops A, B, C, D into your running app, in a small panel on the page you were already looking at. You click until one stops bugging you. "Oh I like B." Nothing is written to source.

Your reactions are recorded word for word along the way. They are the convergence history, and they feed the taste record.

That's the review. You stopped describing what you wanted and pointed at it.

Annotate

And when the page is already in front of you, you don't describe anything. You point.

/craft:annotate

Craft puts a comment sheet on the tab you have open. Turn on COMMENT MODE, click anything, type what you want, press SEND TO CLAUDE. The change lands on the page while you watch. No file changes while you point.

One real run started on a plain white profile card:

"Can you make this look a bit more like LinkedIn?"

Eleven pins later, the last one was:

"Make craft look like it's coming off the page"

By then the card was a floating dark terminal with 3D CRAFT letters. No reload. No file touched. Then: "That's exactly what I wanted. Can we apply this change to our code now?"

"Cleared - the page is showing real code again."

Adhoc ported the look as one tweak.

Along the way:

• Every pin gets a live attempt. Craft changes the page, measures the result, and tells you what the page shows, not what it meant to do.
• Pins know their source. Each arrives with the element you clicked and, when craft can find them, the component and stylesheet rule behind it.
• Later pins win, and craft says so. The terminal replaced the LinkedIn banner, and you hear which earlier changes got covered.
• The run is one record. Your pins word for word, where each lives in source, and the stylesheet with one block per pin, in .craft/annotations/.
• It leaves on your word. A tweak through /craft:adhoc, a story the record pre-fills, a notebook todo, or nothing. A run cut short is offered back next time.
• Outside pages are untrusted. On a page that isn't local, craft treats pins as page content, says so once, and asks before anything beyond a visual change.

The step-by-step guide is docs/annotate.md.

The Notebook: project memory across sessions

The notebook is one-line capture for thoughts that aren't story-shaped yet. You never fill out a form. You just talk:

"Can you check our notebook todos?"

"Create a notebook entry for a craft:reskin command with optional token extraction."

• Three kinds of entry. Ideas that may mature into stories, todos that need doing, and notes: durable project facts future-you will want recalled.