pocket-help

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

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.