Top 5 Skills to Install
in the Claude Desktop App

Use /skill-creator to build me a skill called `grill-me`.

Here is the full spec. Paste this whole block. Skill-creator will turn it into a working SKILL.md and save it.

---

# /grill-me — Stress-Test Any Decision, Plan, or Idea

**Trigger:** `/grill-me [decision, plan, idea, or project]`

**Purpose:** Interrogate the user about whatever they paste in. Find the holes. Surface the blind spots. Make sure their thinking is aligned with what they actually want before they commit time, money, or reputation to it. The goal is alignment and honesty, not destruction.

This skill is the opposite of yes-man Claude. No validation, no "great idea," no "here are 5 things you're doing right." Push.

---

## Behavior

When triggered, run the following 5 rounds in order. Ask ONE question at a time. Wait for the answer before moving to the next question. Do not move on if the answer is vague. Push back until it is specific.

### Round 1: Mirror

Restate the idea back to the user in your own words. Two sentences max. Then ask:

> "Is that what you're actually proposing, or did I miss something?"

Do not move to Round 2 until they confirm or correct.

### Round 2: The Premise

Ask these one at a time:

1. Why this idea, and why now? What changed?
2. What evidence convinced you this is worth doing? Name it.
3. Who else has tried this exact thing? What happened to them?
4. If you delayed this by 6 months, what specifically breaks?

If they hedge ("I think," "probably," "it feels like"), name it: "You're hedging. What's the actual answer?"

### Round 3: The Mechanism

Ask these one at a time:

1. Walk me through the first 72 hours. What is the literal first action you take?
2. What are you assuming has to be true for this to work? List 3.
3. Where is the leverage point? What single thing matters most?
4. Describe one specific day where this is working. What is happening?

If they describe outcomes instead of actions, push: "That is the result. What is the action that gets you there?"

### Round 4: The Failure Modes

Ask these one at a time:

1. What kills this? Be specific. Not "lack of motivation". What, specifically.
2. What part of this plan are you hand-waving past? Where is the magic happening?
3. Who else loses if this works? What might they do about it?
4. What is the cheapest version of this you could ship in 7 days that would tell you whether you are right?

### Round 5: The Mirror, Pt 2

Ask these one at a time:

1. What would make you quit this in 90 days?
2. Six months from now, what does "this worked" look like in actual numbers?
3. What are you actually optimizing for here? Money, freedom, learning, status, proof to someone? Pick one.
4. If a friend pitched you this exact plan tomorrow, what would you tell them?

### Final Output: The Audit

After Round 5, write a one-page audit with this exact structure:

```
# Audit: [Their Idea]

## The 3 holes I found

1. [Specific hole]
2. [Specific hole]
3. [Specific hole]

## The 1 thing you haven't thought about

[Specific blind spot]

## The version of this I'd ship if I were you

[A revised, sharper version of their plan, 3-5 sentences]

## The single question to answer before you move forward

[One question]
```

---

## Tone rules

- Warm but unflinching. You are the friend who is saving them from themselves, not the enemy.
- Direct, no padding, no "great question." Get to the point.
- Push on vague answers. "Say more." "Be specific." "What does that actually look like?"
- Never validate prematurely. Validation comes only in the final audit, and only for the parts that earned it.
- Do not give advice during rounds 1-5. Only ask questions. Save the advice for the audit.

---

## Edge cases

- If they refuse to answer a question, ask why. The refusal is the data.
- If they get defensive, name it once: "I notice you're defending instead of answering. The point of this is finding holes, not winning."
- If their plan is actually solid, the audit can say so. But only after you have legitimately tried to break it for 5 rounds.

Use /skill-creator to build me a skill called `session-handoff`.

Here is the full spec. Paste this whole block.

---

# /session-handoff — End-of-Session Memory Dump

**Trigger:** `/session-handoff`, "end session", "handoff", "wrap up", "save session"

**Purpose:** At the end of a working session, write a detailed handoff note so the next session (or the next person, or future-you) can pick up exactly where you left off. Claude has no persistent memory between sessions. This is the bridge.

---

## Behavior

When triggered, do these steps in order.

### Step 1: Scan the session

Read the full conversation from this session. Identify:

- What was actively being worked on (the main thread)
- What was completed in this session
- What is in progress and not yet done
- What blockers or open questions exist
- Key decisions made (and the reasoning)
- File paths, URLs, commands, or names that matter
- What the next concrete action should be

### Step 2: Write the handoff file

Save the note to:

```
.claude/handoff/YYYY-MM-DD-HHMM-handoff.md
```

(Use the actual date and time. If the folder doesn't exist, create it.)

Use this exact structure:

```markdown
# Session Handoff — YYYY-MM-DD HH:MM

## Working On
[1-2 sentences. The main thread of the session.]

## Completed This Session
- [Bullet. Specific. Include file paths if relevant.]
- [Bullet.]
- [Bullet.]

## In Progress
- [What is started but not finished. Where exactly the work stopped.]
- [Include the last working state: file, line, command, URL.]

## Blockers / Open Questions
- [Anything unresolved. Things that need a decision before continuing.]

## Key Decisions Made
- [Decision]: [Reasoning, one line]
- [Decision]: [Reasoning, one line]

## Key References
- File paths touched
- URLs opened
- Commands run that matter
- Names of people, tools, projects mentioned

## Next Move
[ONE sentence. The single most important thing the next session should do first. Not "continue the work". Be specific. "Run npm test, fix the failing assertion in line 42 of cart.test.ts, then commit."]
```

### Step 3: Confirm

Output one line to the user:

```
Handoff saved to .claude/handoff/YYYY-MM-DD-HHMM-handoff.md
Next move: [the next move from the file]
```

---

## Rules

- Be specific. "Worked on the website" is useless. "Updated the pricing copy on /pricing.astro lines 40-60, still need to test the mobile breakpoint" is the standard.
- Include exact file paths, exact commands, exact line numbers when you can.
- The "Next Move" is the most important field. If a stranger read only that one line, they should be able to pick up the work.
- Never skip a section because "nothing happened there." Write "None" instead. That is information too.
- If the session was a research or thinking session with no code changes, the handoff still applies. Decisions and direction are valuable handoff content.

Use /skill-creator to build me a skill called `resume`.

This skill is the pair to `session-handoff`. Install session-handoff first. Then paste this whole block.

---

# /resume — Pick Up Where You Left Off

**Trigger:** `/resume`, "resume", "where were we", "continue from last time"

**Purpose:** Read the most recent session handoff and reorient. Pull yourself (Claude) and the user back into the working state of the last session so no time is wasted re-explaining context.

---

## Behavior

When triggered, do these steps in order.

### Step 1: Find the latest handoff

Look in `.claude/handoff/` for the most recent file by filename timestamp (files are named `YYYY-MM-DD-HHMM-handoff.md`).

If the folder doesn't exist or is empty, output:

```
No handoff found. Either this is the first session, or /session-handoff wasn't run last time.
What are we working on?
```

And stop here.

### Step 2: Read and summarize the handoff

Read the full handoff file. Output a tight summary to the user in this format:

```
**Resuming from [date and time of last handoff]**

We were working on: [the "Working On" line]

Last session you finished:
- [Completed item 1]
- [Completed item 2]

What's open right now:
- [In progress item]
- [Blocker, if any]

The next move (from your last handoff): [the Next Move line]
```

### Step 3: Confirm direction

End with one question:

> "Ready to pick that up, or do you want to do something else?"

Wait for the answer before doing any work.

---

## Rules

- Do not start doing work until the user confirms direction. The handoff is a map, not an order.
- If the handoff is more than 7 days old, flag it: "Note: this handoff is from [N] days ago. The state may have shifted. Want me to verify anything before we start?"
- Never invent context that isn't in the handoff file. If something is unclear, ask.
- Keep the summary short. The point is to get back to work fast.

Use /skill-creator to build me a skill called `memory`.

This is your cross-session memory layer. Run it at the end of any session where something durable happened.

---

# /memory — Cross-Session Memory Update

**Trigger:** `/memory`, "update memory", "save memory", "end of session"

**Purpose:** Review what happened this session and save anything that should persist across future sessions. Cross-session memory is what turns Claude from a stateless assistant into a long-running collaborator that actually knows you.

---

## Behavior

### Step 1: Read current state

Read these files if they exist:

- `MEMORY.md` (in the project root): what's already saved
- `USER.md` (in the project root): current focus and working profile

If they don't exist, create both with starter templates. `MEMORY.md` is a running index of long-lived facts. `USER.md` is a profile of who the user is, what they're working on, and how they want to be collaborated with.

### Step 2: Scan the session for save-worthy content

Save to `MEMORY.md` if any of these came up:

- A new project was started, or a project's status changed materially
- A key decision was made (pricing, positioning, architecture, scope)
- A skill, tool, workflow, or system was built or replaced
- A new collaborator, client, or contact was introduced
- An API key, integration, or account was set up
- A preference, rule, or hard "do not do this" was established

Save to `USER.md` → Current Focus if:

- The user's active priorities shifted from what's listed
- A major task in Current Focus was completed
- A new initiative became the top priority

Do NOT save:

- Draft content, scripts, emails, copy. Those belong in content folders, not memory
- One-time deliverables
- Things already accurately captured
- Ephemeral session state

### Step 3: Write the updates directly

Edit `MEMORY.md` and `USER.md` in place. Don't ask for approval on individual items. Make the calls.

- `MEMORY.md` is an index, not a wall of text. Each entry is one line or one bullet under a topic header. Bullets > paragraphs.
- `USER.md` → Current Focus is max 3 bullets. Replace, don't append.

### Step 4: Report what changed

Give a one-screen summary:

```
Memory updated:
- MEMORY.md: [what changed, 1 line per update]
- USER.md: [what changed, or "no change"]
```

If nothing was worth saving:

```
Memory checked. Nothing new to save.
```

---

## Rules

- Be decisive. Borderline = save. Better to have slightly more than to lose something useful.
- Don't rewrite sections that are still accurate. Only touch what changed.
- The goal: future-you reads `MEMORY.md` at the start of a new session and has the full picture without re-exploring.
- This is not a journal. Save state and decisions, not feelings or recaps.