# approve

Adopt this skill: https://proskills.md/skills/other/drobins25-craft-skills-approve

Page: https://proskills.md/skills/other/drobins25-craft-skills-approve
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/approve/SKILL.md
size: 4583
upstream: https://github.com/drobins25/craft/blob/main/skills/approve/SKILL.md

````text
---
name: approve
description: "Request write permission from the user before making file changes. MUST be invoked before any write attempt when the write gate is closed. Creates scoped approval via AskUserQuestion + TaskCreate, opens the write gate, and closes it when work is done. Triggers: write hook blocks an edit, agent is about to write files outside .craft/, agent needs to modify project source files. This skill requires user approval 100% of the time - never bypass AskUserQuestion."
allowed-tools: ["Read", "Bash", "Glob", "Grep", "AskUserQuestion", "TaskCreate", "TaskUpdate", "TaskList"]
---

# Write Approval

You are requesting permission to write files. This skill gates ALL writes outside `.craft/` and `.claude/` directories. It requires explicit user approval every single time - no exceptions, no bypass, no auto-approve.

## When to Use

Call this skill BEFORE your first write attempt when:
- The write hook has blocked you (or will block you)
- You're about to modify project source files
- You're about to create new files outside `.craft/`
- Any workflow stage involves writing to the project

Do NOT call this for writes to `.craft/` or `.claude/` directories - those are always allowed.

## The Flow

### Step 1: Describe the Scope

Before asking for approval, gather what you're about to do. Be specific:
- Which files will be created or modified
- What changes will be made (brief, not the full diff)
- Why (what triggered this - workflow stage, fix, feature work)

### Step 2: Ask for Approval (MANDATORY)

Use **AskUserQuestion**. This step CANNOT be skipped. Ever.

```
question: "I need write access to make these changes. Approve?"
header: "Write Access"
options:
  - label: "Approve"
    description: "{summary of what will be changed}"
  - label: "Deny"
    description: "Block these changes"
  - label: "Modify scope"
    description: "I want to adjust what's allowed"
```

**If "Deny"** -> Stop. Do not open the gate. Report to the caller that writes were denied.

**If "Modify scope"** -> Let the user describe the adjusted scope. Re-present the AskUserQuestion with the new scope. Loop until approved or denied.

**If "Approve"** -> Continue to Step 3.

### Step 3: Create Approval Tasks

Create exactly two tasks:

**Task 1 - The approved work:**
```
TaskCreate({
  subject: "Approved: {brief description of changes}",
  description: "Files: {file list}. Scope: {what was approved}.",
  activeForm: "Writing approved changes"
})
```
Set this task to `in_progress` immediately.

**Task 2 - Close the gate:**
```
TaskCreate({
  subject: "Close write gate",
  description: "Set CRAFT_WRITE_ENABLED='' after approved work is done.",
  activeForm: "Closing write gate"
})
```
Set `addBlockedBy` to Task 1's ID so it can't complete before the work is done.

### Step 4: Open the Gate

Run via Bash:
```bash
${CLAUDE_PLUGIN_ROOT}/hooks/scripts/update-global-state.sh CRAFT_WRITE_ENABLED true
```

The write gate is now open. The agent can write files.

### Step 5: Do the Work

The caller (workflow, fix skill, implementer, etc.) performs the approved changes. As work completes, the approved-work task stays `in_progress`.

**This skill does NOT do the writing itself.** It opens the gate and returns control to the caller. The caller writes, then calls back to close.

### Step 6: Close the Gate

When the approved work is done, the caller MUST close the gate:

1. Mark the approved-work task as `completed`:
```
TaskUpdate({ taskId: "{task-1-id}", status: "completed" })
```

2. Close the write gate:
```bash
${CLAUDE_PLUGIN_ROOT}/hooks/scripts/update-global-state.sh CRAFT_WRITE_ENABLED ""
```

3. Mark the close-gate task as `completed`:
```
TaskUpdate({ taskId: "{task-2-id}", status: "completed" })
```

## Safety Rules

1. **AskUserQuestion is mandatory.** Every invocation. No exceptions. If the skill is called 5 times in a session, the user is asked 5 times.
2. **Scope is enforced by visibility.** The user sees exactly what was approved via the Task description. If the agent writes files outside the approved scope, that's visible in the task trail.
3. **Gate closes explicitly.** The gate does not auto-close on a timer. The caller must close it. If the session ends with the gate open, `session-start.sh` will detect CRAFT_WRITE_ENABLED=true with no active story/workflow and reset it.
4. **No nesting.** If the gate is already open (from a story or another approval), this skill is not needed. Check first:
```bash
grep "CRAFT_WRITE_ENABLED" "${CRAFT_PROJECT_ROOT:-.}/.craft/.global-state"
```
If already `true`, skip this skill.
````

## File: README.md
upstream: https://github.com/drobins25/craft/blob/main/README.md

````text
<div align="center">

# Craft

**Stop Vibing. Start Crafting.**

[![version](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fraw.githubusercontent.com%2Fdrobins25%2Fcraft%2Fmain%2F.claude-plugin%2Fplugin.json&query=%24.version&label=version&color=blue)](CHANGELOG.md)
![license](https://img.shields.io/badge/license-MIT-green)
![status](https://img.shields.io/badge/status-actively%20developed-brightgreen)
![requires](https://img.shields.io/badge/requires-Claude%20Code%202.1%2B-orange)
[![Listed on ClaudePluginHub](https://www.claudepluginhub.com/badge/drobins25-craft)](https://www.claudepluginhub.com/plugins/drobins25-craft?ref=badge)

**[Install](#install)** · [Getting Started](#getting-started) · [Commands](#commands) · [How it works](#how-craft-work-flows) · [What's New](CHANGELOG.md)

### Point at the page. Watch it change.

One comment sheet, built into three commands.

<img src="https://raw.githubusercontent.com/drobins25/craft/assets/craft-annotate.gif" alt="A plain white profile card morphs pin by pin into a glowing dark terminal - comments drop onto the live page one after another, the last one asks to make CRAFT look like it's coming off the page, the letters pop out in 3D, and clearing the pins leaves the finished card." width="520">

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

</div>

| [`/craft:annotate`](docs/annotate.md) | [`/craft:mockup`](#the-mockup-funnel) | [`/craft:dial`](#the-mockup-funnel) |
|---|---|---|
| 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](#install).

## 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 - a terminal conversation on the left drives an adhoc tweak, while on the right the Craft Open Source interface assembles itself in response.](https://raw.githubusercontent.com/drobins25/craft/assets/craft-caught-in-the-act.gif)

*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](https://darinbuilds.com)** - an immersive single-page portfolio and marketing site (Next.js, GSAP scroll), built across 30+ craft cycles.
- **[throve.fit](https://throve.fit)** - a structured daily coaching app: week-view programming, curated workouts with real coach's notes, exercise alternatives, and completion tracking.
- **[hirecalling.jobs](https://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](https://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 variatio
````
