SpotMe plugin
Gym mode for agentic coding: an OpenCode and Pi plugin hands you pieces of code and reviews your solution
- 197 ★ on the repository
- Last commit
Extended access
Why this level
- Intercepts code-writing tools in OpenCode and Pi and creates scaffold files in the project
- The agent may pause the task until you act, and a submitted exercise is judged by the model
Install
- Works in
Manual install
{"$schema":"https://opencode.ai/config.json","plugin":["spotme"]}Add to `opencode.json`.
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- Intercepts code-writing tools in OpenCode and Pi and creates scaffold files in the project
- The agent may pause the task until you act, and a submitted exercise is judged by the model
This is third-party code. Review the repository files before installing.
What it does
SpotMe changes the agent's role: instead of writing all the code it scaffolds a logical unit, hands it to the human and, after a review, returns to work. The mode is enabled with `/spotme:on [lite|medium|hard] [--every N]` at the start of a session. Every N code-writing actions (2 by default) the agent creates a scaffold file with a `# SPOTME: ...` marker and stops. The human writes the marked section in their editor, then `/spotme:done` runs a review with a short assessment, and the agent resumes the original task. Difficulty sets the amount: on `lite` the agent gives the signature, docstring and structure and you write the body; on `medium` only the signature with a spec comment; on `hard` just a plain-English description. The other commands: `/spotme:status`, `/spotme:rep` (an exercise on demand), `/spotme:hint` (one hint), `/spotme:solve` (concede, the agent finishes), `/spotme:skip` and `/spotme:off`. The plugin works in OpenCode and Pi, and without automatic interception the `SKILL.md` skill plugs into any agent supporting AgentSkills.
Who it is for. Developers who write code together with an agent and do not want to lose their skills: they write part of the logic themselves and the agent reviews the result.
Good fit when
- The agent writes all the code for you and you want to keep practicing: every couple of actions it leaves you a piece of logic
- You learn a new technology on a real project and want exercises with hints on request
- After your implementation you want a short assessment with corrections before the agent moves on
- Difficulty changes during the work: from a ready structure to a plain-English description
Not a fit when
- You need to close the task as fast as possible: every exercise stops the agent until you implement it
- The environment is neither OpenCode nor Pi: without the plugin the action counter does not fire and only the skill with commands remains
- The code has to reach production today without your involvement: then turn the mode off with `/spotme:off`
- You work in a language or files where the scaffold marker comment breaks the build
Example request
/spotme:on medium --every 3 and then add pagination to this service, leaving part of the logic for meLimitations
- Automatic interception of code writing works only in the OpenCode and Pi plugin. The `SKILL.md` skill for other agents gives the commands, but the action counter does not fire by itself.
- The agent writes a scaffold and leaves a `# SPOTME: ...` marker in it, which has to be removed after the exercise.
- Building and checking the repository uses Bun. The Pi package installs with `pi install npm:spotme`.
- The repository has no license file, so usage terms are not stated.
How to disable. The `/spotme:off` command turns the mode off, after which the agent writes code as usual. Remove the plugin from the `plugin` array in `opencode.json` for OpenCode, and delete the Pi package with `pi remove`.
FAQ
How do I install SpotMe in OpenCode?
Add `"plugin": ["spotme"]` to `opencode.json`. For Pi use `pi install npm:spotme`. In both cases the mode is turned on with `/spotme:on`.
How does the exercise loop work?
The agent writes a scaffold with a `# SPOTME: ...` marker, you implement the marked section and `/spotme:done` runs the review. If you are stuck, `/spotme:hint` gives one hint and `/spotme:solve` hands the solution to the agent.
How do lite, medium and hard differ?
On `lite` the agent gives the signature, docstring and structure, on `medium` the signature and a spec comment, on `hard` only a plain-English description. The higher the level, the more you write.
How often does the agent give exercises?
Every N code-writing actions. N is 2 by default and can be changed with the `--every N` flag when enabling the mode.
Does SpotMe work in Claude Code?
The automatic action counter does not, but `SKILL.md` can go into the skills directory of any agent supporting AgentSkills. Commands then work and exercises start by instruction without automatic interception.
Discussion
No questions or reviews yet.
Related
PluginsA Windows plugin for OpenCode Desktop that sets edit boundaries, screens commands and ties test results to the current code.
A mirror of Lauren Tan's pstack set from Cursor: over 50 skills, the poteto-mode with 23 playbooks and 24 principles for strict agent work on code
A plugin and skill that makes the agent write minimal code: reuse, stdlib and native platform features come first
Procoder is a single Go binary with a commit gate, quality controllers and a lessons ledger so agents cannot ship unfinished work
A Pi agent package: code search, LSP, web search, desktop control and confirmations for risky commands.
MiniCode is a compact TypeScript terminal coding agent like Claude Code: tool loop, TUI, skills, MCP and sub-agents, built for study and tinkering
README in short
The README is delivered with humor: it explains the idea of a gym mode for code and compares the agent to a spotter. Then come the five steps of the loop, tables of commands and difficulty levels, installation for OpenCode and Pi, a fallback with the skill alone, a section on local development with Bun checks and an explanation of the name.