1% Moves Only

The pattern in one phrase: one yes, listed exceptions.

1. What it does

Once you approve a plan, it makes the agent run every step on its own without stopping to ask again — and it only pauses for a short, named list of "stop signs."

2. The problem it solves

You approve the plan, you say "go" — and then the agent asks you again. And again. "Ready to proceed?" "Want me to run step 2?" "Should I commit now?" Every few minutes it stops, restates what you already agreed to, and hands you a menu of choices you already made. It feels like hiring a contractor who has the blueprints in his hand but knocks on your door before hammering every single nail. The work doesn't move; *you* become the bottleneck. By the tenth "are you sure?" you're more tired than if you'd done it yourself.

This skill kills that. You say "go" once, and the agent treats that yes as real — it executes the whole plan and only interrupts you for the things that actually deserve an interruption.

3. The core pattern (the part you steal)

One yes, listed exceptions: get approval once, then honor it until a named line is crossed.

Two halves make this work, and both are reusable anywhere:

A yes means yes — until it expires. When you approve the plan, that approval *is* the green light for every step inside it. The agent doesn't re-ask at each step, because re-asking is treating your decision as if it didn't count. But the yes isn't forever: it runs out the moment you change a step, ask something unrelated, or a fact on the ground proves the plan wrong. Think of a surgeon. You sign one consent form before surgery, and you don't get woken up mid-operation to approve each stitch — but if they open you up and find something the scans never showed, *that's* when they stop and talk to you.
Write down the short list of "stop signs" in advance. The agent isn't trusted to run free on *everything*. There's a small, explicit list of actions that always force a pause: anything hard to undo (deleting production data, force-pushing), anything sent on your behalf (an email, a public comment), anything that touches money, security, or private info. Everything *not* on that list is fair game. This is the trick — by naming the dangerous exceptions up front, you can safely say "do everything else without asking." It's the same logic as a "break glass in case of fire" box: 99% of the time you leave it alone, but the one rule is crystal clear so nobody hesitates when it matters.

That combo — *one durable approval + a pre-written list of hard stops* — is the transferable lesson. It works for any helper, human or AI, who you want to move fast but not blow up your house. Define the few things that always need a check-in, and let them own everything else.

4. How the skill is actually built

Look at the real file: ~/.claude/skills/1pct-moves-only/SKILL.md. Its shape:

Frontmatter (the top block): name: 1pct-moves-only and a long description packed with trigger phrases — "just do it", "keep going", "stop asking", "stop hedging and execute." Those phrases are the on-switch. They also tell the agent when *not* to fire: it deliberately skips genuinely risky requests, so frustration words don't override safety.
The body — the doctrine: most of the file is plain-English rules that define the behavior. It defines a "1% move" (a real forward step the plan already implies, not planning or asking). It spells out scope of approval — what the yes covers, and the four ways it expires. It lists the stop signs in a table (one-way doors, external sends, shared-infra changes, data/auth/privacy, a plan assumption proven false). And it names speed bumps — small things like "I haven't done this before" that look like reasons to pause but aren't.
The self-check: before sending any message, the agent silently runs a short audit — "Am I asking permission for a step that's already approved? Then delete the ask and just do it." There's also a rationalization table that pairs each common stalling thought ("Ready to implement?") with the corrected behavior, so the line between a real concern and a fake one is visible.
Helper files: the doctrine mentions an enforcement hook (a small script, hooks/1pct-check.py) that runs automatically and catches the agent when it slips back into asking, plus an evals/ folder that measures how often it pauses when it shouldn't. The rules teach the behavior; the hook makes it stick.

5. How YOU could build your own

You don't need the enforcement hook to start. Here's the minimum:

Write your stop-sign list first. Name the handful of actions that should *always* trigger a pause — for most people that's: anything hard to undo, anything sent to other people, anything involving money or passwords. Keep it short. This list is the whole safety net.
Write the rule: "after I approve a plan, do every step without re-asking — except the stop-sign list." That one sentence is the core of the skill.
Add the expiration clause. Tell the agent the approval ends if you change a step, ask something unrelated, or reality contradicts the plan. This is what keeps "stop asking" from becoming "ignore me."
Add a self-check line. "Before sending a message, ask yourself: am I requesting permission for something already approved? If yes, delete the question and just do it." That one habit removes most of the nagging.

That's a working version. The auto-enforcing hook and the measurement folder are polish you add later.

6. When to use it — and when NOT to

Use it when: you've already approved a clear plan and you want the agent to *execute* it end-to-end without check-ins at every step — a build, a multi-step refactor, a documented sequence of tasks.
Skip it when: you're still in the planning or brainstorming phase and you actually *want* options and back-and-forth, or when the next move is genuinely a one-way door (deleting real data, sending something public). The skill itself is built to step aside for those — don't use "stop asking" to bulldoze through a decision that deserves a human.

7. The stripped-down version

This is a complete, working version of the pattern. Paste it, edit the stop-sign list to fit your world, done:

---
name: just-execute
description: After I approve a plan, run every step without re-asking. Use when I say "go", "just do it", "keep going", or "stop asking" — NOT during planning, and never for the stop-sign list below.
---

# Just Execute

Once I approve a plan, treat that as approval for EVERY step in it.
Do not re-ask, re-summarize, or offer menus between steps. Run the
next step, report the result in one line, run the next.

ALWAYS STOP AND CONFIRM (the stop-sign list):
- Anything hard to undo (deleting data, force-pushing, wiping files)
- Anything sent on my behalf (email, public comment, message, post)
- Anything touching money, passwords, or private info
- When a fact you observe proves the plan wrong

The approval EXPIRES if: I change a step, ask something unrelated,
or reality contradicts the plan. Then go back to asking.

Before each message, check silently: am I asking permission for a
step that's already approved? If yes, delete the question and do it.