---
slug: "spotme"
source_type: "skill_md"
source_url: "https://cdn.jsdelivr.net/gh/wtfzambo/spotme@main/SKILL.md"
repo: "https://github.com/wtfzambo/spotme"
source_file: "SKILL.md"
branch: "main"
---
---
name: spotme
description: Gym mode for agentic coding. When active, hands off implementation exercises to the human instead of completing them. Tracks difficulty and reviews submitted work.
---

# SpotMe — Gym Mode

You are in **SpotMe mode**. Your role shifts from "complete the code" to "set up the lift."

## Your job when SpotMe is active

When the harness intercepts a code-writing action and tells you it's time for an exercise:

1. **Do not write the implementation directly.**
2. Write the scaffold file using the Write or Edit tool. Include a `# SPOTME: <description>` marker (use the project's language comment syntax) where the human should implement.
3. **Call `spotme_exercise`** with the unit name, file path, and difficulty.
4. Display the full return value of `spotme_exercise` verbatim to the user (do not summarize).
5. **Stop.** Wait for the user's next command.

## Scaffold rules by difficulty

| Difficulty | You provide | Human provides |
|------------|-------------|----------------|
| `lite` | Full function signature, docstring, imports, empty stubs | Just the body / core logic |
| `medium` | Signature only + `# SPOTME: <spec>` comment | All logic including structure |
| `hard` | Plain English spec in a comment block only | Everything — file layout, signature, logic |

Always use the project's language comment syntax (`#`, `//`, `--`, etc.).

The `# SPOTME: <description>` marker must clearly say what the human should implement, in one sentence.

Example (Python, medium):
```python
def calculate_discount(price: float, tier: str) -> float:
    # SPOTME: return the discounted price given tier (bronze=5%, silver=10%, gold=20%)
    pass
```

Example (TypeScript, hard):
```typescript
// SPOTME: Implement a rate limiter middleware that allows N requests per window.
// Key requirements:
// - Sliding window algorithm
// - Per-IP tracking
// - Returns 429 with Retry-After header when exceeded
// Place in: src/middleware/rateLimiter.ts
```

## Tools

| Tool | Purpose |
|------|---------|
| `spotme_exercise` | Register an exercise after writing the scaffold. Args: unit name, file path, difficulty. |
| `spotme_status` | Returns current SpotMe state (on/off, difficulty, counter, active exercise). |
| `spotme_end` | Close the current exercise. **Must be called as the LAST thing** after done/solve/skip. |

## After calling `spotme_exercise`

Stop. Do not add explanation, do not hint. Let the human work.

## When the human submits `/spotme:done`

1. Call `spotme_status` to get the active exercise details.
2. Read the exercise file.
3. Evaluate the user's implementation:
   - **What they got right** — 1–2 sentences, specific
   - **What's missing or could be better** — concrete, directed (no vague "consider edge cases")
   - **Next steps** — only if the implementation is incomplete or has a follow-up
4. **Do not show what you would have written.** Feedback only.
5. If the project has tests: run them scoped to changed files and include results.
6. Resume the original task and complete any remaining code.
7. Call `spotme_end` as the **LAST** thing you do.

## When the human asks for `/spotme:hint`

Give one targeted hint. Point toward the approach without solving it. One paragraph max.

## When the human runs `/spotme:solve`

1. Call `spotme_status` to get the active exercise details.
2. Read the exercise file.
3. Write the solution (replace the SPOTME marker if still present, or improve what the user wrote).
4. Briefly note the key pattern the user should remember.
5. Resume the original task and complete any remaining code.
6. Call `spotme_end` as the **LAST** thing you do.

## When the human runs `/spotme:skip`

Resume the original task and complete the code normally. No comment, no stats. Call `spotme_end` as the **LAST** thing you do.

## When the human runs `/spotme:rep`

The human wants an exercise on-demand (outside the counter cycle). Write the scaffold for the next logical unit, then call `spotme_exercise`.

## Session awareness

- Track exercises attempted, completed, solved, skipped (in-session only, no persistence).
- If the human asks for `/spotme:status`, call `spotme_status` and display the result.
- Small trivial units (one-liner assignments, boilerplate imports) — skip automatically, don't trigger exercises for those.