Pocket Help

The map of the Pocket ecosystem. Read this first to understand the workflow, choose the right skill, and continue from the current stage without loading every

SKILL.md

Core principle: Orient cheaply, then load deep. This skill summarizes and routes; open an individual skill only when reaching the stage that uses it.

What Pocket Is

Pocket is a set of skills for systematic development — from a vague idea to reviewed code. It breaks work into bounded stages with explicit gates: explore → specify → plan → structure → develop → close.

Each stage produces an artifact (pitch doc → spec → execution plan → task files → commits → review reports) that the next stage consumes.

Skill Roles

Role	Skills	Use for
Chained workflow	`pocket-pitching` · `pocket-grinding` · `pocket-planning` · `pocket-structuring` · `pocket-development` · `pocket-closing`	Features and non-trivial work that benefit from reviewed handoffs between stages.
Standalone workflow	`bug-hunting` · `hotfix` · `brand-design` · `structured-research` · `pocket-help` · `pocket-init` · `pocket-education`	Focused work, onboarding, or guidance that does not need the full pipeline.
Optional adapter	`pocket-enterprise`	Remote lifecycle synchronization, only when the user explicitly enables Enterprise.

The

pocket-*

prefix identifies Pocket-owned skills; it does not mean every one is a pipeline stage.

pocket-help

pocket-init

, and

pocket-education

are standalone helpers, while

pocket-enterprise

is an optional adapter.

Router — Which Skill Right Now?

Your situation	Skill	Kind
Rough idea, no clear problem yet — need to explore	`pocket-pitching`	chained
Clear problem — need a spec + acceptance criteria	`pocket-grinding`	chained
Approved spec — need a TDD execution plan	`pocket-planning`	chained
Execution plan ready — sequence/phase it	`pocket-structuring`	chained
Plan or phase file ready — execute task-by-task	`pocket-development`	chained
Phase-level pass complete — reconcile and close	`pocket-closing`	chained
A bug, a failure, or "audit this code"	`bug-hunting`	standalone
Small-to-medium change, full pipeline is overkill	`hotfix`	standalone
Design system / brand identity / UI tokens	`brand-design`	standalone
An assumption to validate before planning	`structured-research`	standalone
New to Pocket or unsure which skill fits	`pocket-help`	standalone
Existing repo needs a local project guide or learner calibration	`pocket-init`	standalone
Learner wants to do the task themselves, with guidance and review	`pocket-education`	standalone (education)
User explicitly enables remote lifecycle synchronization for a compatible Core install	`pocket-enterprise`	optional adapter

Routing rules of thumb:

Don't know if the problem is well-formed? →
```
pocket-pitching
```
.
Problem is clear but needs a real feature plan? →
```
pocket-grinding
```
.
It's a quick, well-understood change? →
```
hotfix
```
.
Something is broken? →
```
bug-hunting
```
.
Holding an unverified assumption? →
```
structured-research
```
.
Already have an approved spec? →
```
pocket-planning
```
.
Repo has Pocket Education on, or the user says "teach me / I want to do it myself"? →
```
pocket-education
```
(the human implements).
User explicitly asks to enable Enterprise lifecycle synchronization? →
```
pocket-enterprise
```
; never infer this from credentials or repo configuration.

The End-to-End Flow

text

rough idea
   │  pocket-pitching     explore → pitch doc             [user chooses next]
   ▼
clear problem
   │  pocket-grinding     BDD discovery → approved spec   [hands off to planning]
   ▼
approved spec
   │  pocket-planning     TDD plan → full task packets    [routes to structuring]
   ▼
execution plan
   │  pocket-structuring  index + task files              [development handoff]
   ▼
plan / phase file
   │  pocket-development  task execution + in-loop audits [phase-level pass]
   ▼
reviewed phase
   │  pocket-closing      verdict reconciliation + close  [when closeout is authorized]

Handoff facts that matter:

```
pocket-grinding
```
hands an approved spec to
```
pocket-planning
```
.
```
pocket-planning
```
validates the plan and routes all plans to
```
pocket-structuring
```
.
```
pocket-structuring
```
creates an execution index and per-task files. It hands off to
```
pocket-development
```
when the user's existing instruction authorizes execution; otherwise it asks once for the missing authorization.
```
pocket-development
```
executes tasks, records per-task verdicts, runs a phase-level pass, and writes a durable phase handoff. It leaves the phase in
```
REVIEW
```
; if the user's request already authorizes end-to-end closeout, continue to
```
pocket-closing
```
, otherwise name it as the next step.
```
pocket-closing
```
reconciles verdicts and advances a reviewed phase; it appends that phase's section to
```
closeout.md
```
and does not review implementation code. It appends the final plan section after all phases close.
```
pocket-pitching
```
does not auto-chain — the user chooses whether to start
```
pocket-grinding
```
.

For the full stage-by-stage walkthrough, load

references/end-to-end-flow.md

. For concise inputs, outputs, and routing notes, load

references/skill-map.md

Pocket Education (opt-in mentor mode)

With Pocket Education enabled (

/pocketto:pocket-init

Education Gate), the human writes the code and the agent teaches, reviews, and guides with progressive hints (

pocket-education

). The skill-specific learner profile (

foundation

guided

independent

per skill) lives in a

## Pocket Education

block in

AGENTS.md

CLAUDE.md

and is reused across sessions. It can gain a skill dimension when a task needs one; recalibration and persistent level changes remain learner-controlled.

In an Education repo, implementation skills check whether the learner wants guidance or a handoff. An explicit handoff already given in
```
pocket-education
```
authorizes that task; do not ask for the same confirmation again.
Education is local and independent of optional adapters. Without the block, nothing changes and no
```
edu
```
call is made.

Optional Enterprise Adapter

Use

pocket-enterprise

only after the user explicitly enables remote lifecycle synchronization for a compatible Core installation. Core remains local-first without it; do not infer consent from credentials or an existing registration.

When Pocket Beats a Lighter Flow

Use the full pipeline when work has high ambiguity, spans many steps, needs BDD/TDD discipline, or requires phase gates and auditable handoffs.

For smaller work, choose a focused skill:

known bug or failure →
```
bug-hunting
```
small-to-medium change →
```
hotfix
```
design system or UI tokens →
```
brand-design
```
an assumption to validate →
```
structured-research
```

For the full comparison, load

references/pocket-vs-superpowers.md

Context Budget Guidance

Start here to orient and route.
Load one skill for the current stage.
Load that skill's references only when its instructions call for them.

pocket-help

NPX Install

Tags

SKILL.md Content