Craft

Stop Vibing. Start Crafting.

Claude Code plugin: guided + controlled development orchestration harness with built-in workflow + state management, for designing + building durable, production-ready software through the entire product lifecycle - new projects or existing codebases.

Your codebase is read-only by default. Changes never land as a side effect of asking a question - every write goes through a channel you opened: a planned story, an investigated fix, a live tweak, or an approved one-off.

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

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.

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 - a card, a hero, a whole page - and craft's alchemist builds three genuinely different live HTML options. Stances, not variations: at most one option may stay inside your current design language, and at least one has to go further than you dared to ask. Three safe layouts in the current palette counts as a failed round.

You just ask:

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

and craft opens the funnel - three live options, in your browser, at real scale.

From there you converge by reacting in plain words - no forms, no pickers:

• Diverge. Three options at real scale, embedded in real surrounding context. Say which one pulls and what's wrong with the others. Hybrids are legal briefs: "B with C's cards."
• Refine. Your pick becomes the base; the alchemist builds variations of it.
• Polish. The live loop: micro-adjustments are injected straight into the open page while you watch in your own browser. React, keep or discard, next one - seconds per iteration.

And when a reaction is only a feeling - "B is close but something's off" - craft riffs the fuzzy reaction into a sharp direction with you before rebuilding, instead of burning a round on its own guess about what you meant.

Acceptance is explicit - "that's it, ship it" - and then the important part happens: the new design values solidify into tokens.yaml with provenance, before any downstream artifact exists. Every later story, validator, and analyzer now enforces the design you approved in your own browser. The converged mockup then graduates on your call: tweak it in now, grow it into a story (its CSS ports as-is, never reinterpreted), or park it as a notebook todo that remembers everything.

And the mockup isn't the only door into your project's DNA. A two-minute tweak takes the same one:

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

craft routes it to /craft:adhoc, makes the change in place, shows you, and records what you said. Accepted tweaks reconcile the same way a mockup does: when a tweak's final values drift from your tokens or outgrow a lock, craft asks once - at acceptance, never mid-flow - whether the new taste becomes the documented standard. Say yes and it can snowball, offering to sweep the settled rule across every surface it fits. Whether the change arrived through a mockup or a two-minute tweak, your design system ends the session already agreeing with what you approved.

And when the live page is almost there - just a notch off:

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

You don't have to finish that sentence.

/craft:dial drops the options into your running app - A, B, C, D, in a little grey panel on the page you were already looking at. You click until one stops bugging you. "Oh I like B."

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

Your reactions are recorded verbatim along the way - they're the convergence history, and they feed the taste record the notebook builds on.

The Notebook

The notebook is one-line capture for thoughts that aren't story-shaped yet - ideas that may mature into stories, todos that need doing, and durable project facts future-you will want recalled. Entries land with context attached: the story, cycle, or tweak that produced them rides along, so a thought here is work paused, not a promise you'll have to reconstruct from zero.

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."

That second one doesn't exist yet - it's an idea, and ideas in the book can graduate into anything: a tweak, a story, an entire cycle.

And soon, some entries won't be yours at all. When tweaks you loved stack up, craft's scout goes looking for the other places that taste belongs - and writes the todo itself:

Run /craft:mockup on the pricing cards - your last three tweaks kept warming the palette, and these are still cold. Creative direction and origin tweak attached.

You didn't ask for that one. Craft was paying attention.

That's the real reason the notebook exists: your taste compounds. Every design you love is recorded, not spent - a vote for what "good" means in your project. And it climbs: the morphing glow you tweaked onto one flat card becomes the move craft proposes for the row of cards, then the page, then the DNA of a site-wide experience - every step still linked back to the card where it started. Most tools forget what you liked the moment the session ends. Craft keeps score and builds upward from it, until the work isn't just more you - it's you, refined.

Craft holds up its end, too. Drop a deferral mid-story and craft offers the notebook - one ignorable line, never a popup:

"later" · "don't let me forget" · "side note" · "unrelated but" · "before I forget" · "for next time" · "remember to"

The entry lands stamped with the story, cycle, or tweak that produced it. And when a build reaches a step only you can do - a deploy setting, a DNS record - Claude writes the full walkthrough into the book, tied to the work it belongs to, waiting for your hands.

And the book remembers. Every entry knows when it was written and what it became - the one-line thought from three weeks ago is stamped with the story it turned into, and the story knows the line it grew from. Nothing in it is locked into a shape - a line can become a tweak, a story, an entire cycle, a mockup session - and nothing in it forgets where it came from.

Capture syntax, lifecycle, and where files live: Notebook, below.

Why we built it this way

Most agent frameworks treat the model as fixed and harden the harness around it: prompt scaffolding, retry logic, validation chains, every guardrail imaginable. Craft makes the opposite bet. Claude keeps getting smarter; we build around the capability curve instead of fighting it. The harness checkpoints for safety, not for control.

Craft is built with craft. This plugin and the projects shipped with it went through the same cycles, the same locked decisions, the same checkpoints you'll use. Craft does docs the way craft does code.

*The longer story - four months of craft building craft - i