Implementation before requirements are clear
Grinding turns a vague ask into a BDD spec (scope, boundaries, and Given/When/Then acceptance criteria), and an independent edge-case-hunter reviews it before any design is proposed.
AI writes the code.
Pocketto makes the process accountable.
Pocketto adds engineering discipline to Claude Code and Pi: plan before code, delegate with contracts, review independently, and close on your word. You go from a rough idea to reviewed, shipped code without the agent improvising.
pi install git:github.com/rfxlamia/pockettoinstall from the Git repository
npx pocketto-pi setup-extensionsrequired Pi extensions: advisor, context7, subagents
Coding agents are great at writing code and bad at not skipping steps.
Left unconstrained, an agent starts implementing before the problem is defined, delegates without contracts, reviews its own work, and drifts on. Pocketto does not make the model smarter. It puts the process in a harness: explicit stages, explicit artifacts, explicit gates, and a hard close that nothing slips past.
How Pocketto handles this
Ambiguous delegation
Every subagent dispatch is a Pocket Packet: objective, references, deliverables, quality bar, stop conditions. Six iron laws enforce it: no packet, no spawn.
Missing or ineffective reviews
Review is independent by construction: the implementer reports DONE, a mechanical gate runs, and a read-only auditor subagent judges spec compliance and code quality. The coordinator never grades its own work.
Untraceable decisions
Specs, plans, task files, verdicts, and corrections live under docs/pocket/ and log.json, durable and inspectable files you can read months later, not chat scrollback.
Incomplete phase closeout
Closing refuses stale or missing verdicts, advances only passing phases, appends closeout.md, and runs log close only when every phase is DONE, because you explicitly asked for closeout.
Start where your
project is.
You don't have to start at stage one. Choose what you already have, find your next step, and see what that stage turns your input into. Your approval still controls what happens next.
What do you have?
Choose the closest match.
Your next step: PitchingSmall change or a bug? Find a focused workflow.Pitching
Stage 01 of 06Turn a rough idea into a clear problem statement and a few directions worth exploring.
Bring a rough idea, no clear problem statement yet.
Read the Pitching guideInput to output
Illustrative drag-and-drop exampleInputPitchingOutput
Input for Pitching
I want drag and drop that works well for reordering a list.
The Pitching output arrives here.
Where you decide
You choose what happens next.
Continue to Grinding, explore the idea further, or stop here. Pitching never starts Grinding on its own.
Next stage: Grinding. Grinding can read the pitch as context for discovering requirements. The pitch is not an approved spec.
Illustrative only. No skills run and no project approvals are recorded.
Enter where you are.
Keep the whole picture.
- 01Pitching
- 02Grinding
- 03Planning
- 04Structuring
- 05Development
- 06Closing
15 skills. One discipline.
Six pipeline stages for features that deserve the ceremony, nine standalone skills for everything else, all built on the same principle: verification over confidence.
Structured planning and specifications
BDD specs with acceptance criteria, TDD execution plans, file-level task mapping. Test intent travels in the plan; implementation never starts from vibes.
docsDelegation through Pocket Packets
Seven-field contracts with objective, verification criteria, and stop conditions. Parallel groups run in git worktrees, merged and audited one task at a time.
docsIndependent review and quality gates
Edge-case hunters, spec reviewers, in-loop auditors, and a phase-level pass, all read-only, all separate from the agent that wrote the code.
docsDurable lifecycle state
log.json tracks tasks and phases across sessions; lifecycle events record spec approval, phase completion, and closure. Recovery and repair are CLI commands, not hand edits.
docsLocal-first Core
The full pipeline works with zero GitHub credentials. Core commits state and events locally first and never calls gh. No remote required, ever.
docsOptional Enterprise adapter
Opt in, and an additive adapter consumes Core’s events and reconciles GitHub: issues, phase PRs, tasklists. It never merges a PR or closes an issue; humans keep those gates.
docsPocket Education
You write the code; the agent teaches. Per-skill depth (foundation / guided / independent), a hint ladder instead of answers, reviews phrased as traces. The learner owns progression.
docsStandalone workflows
Bug hunting with confirmed root causes, hotfixes with plan review, brand-aware design systems, research with graded verdicts, with no pipeline ceremony required.
docsStart where you actually are.
“I have a rough idea.”
Explore it into a problem statement with approach directions before committing to a spec.
pocket-pitching
“I need to build a feature.”
Run the full pipeline: spec → plan → structured tasks → delegated, reviewed execution → close.
The full pipeline
“I need to fix a bug.”
Reactive and proactive debugging with confirmed root cause before any fix touches the code.
bug-hunting
“It’s a small, clear change.”
A brief plan, an independent subagent review, then implement: accuracy without the ceremony.
hotfix
“I want to write the code myself.”
Opt into Education: the agent explains, reviews your diff, and coaches one hint at a time.
Pocket Education
“My team works through GitHub.”
Add the optional Enterprise adapter: issue reconciliation, stacked phase PRs, final tasklists, with human gates preserved.
Pocket EnterpriseTwo hosts. One install each.
Pocketto ships as a Pi package and a Claude Code plugin, built from the same local-first Core. Pick your host. Everything else (pipeline, standalone skills, Education) behaves the same.
- Pi users: after installing, pull in the required extensions (advisor, context7, subagents) with
npx pocketto-pi setup-extensions, then check withnpx pocketto-pi doctor. - Claude Code users: skills register as
/pocketto:*commands after the marketplace install and a reload. - Node.js ≥ 18. Enterprise is a separate, explicit install. Core never requires it. See Enterprise setup.
New here? Run /pocketto:pocket-help, a compact router that explains the system without loading every skill.
pi install git:github.com/rfxlamia/pockettoinstall from the Git repository
pi install npm:pocketto-pior install from npm
npx pocketto-pi setup-extensionsrequired Pi extensions: advisor, context7, subagents
npx pocketto-pi doctorverify what is installed and what is missing
Your next feature deserves a trail.
Install Pocketto, run one command, and watch a rough ask become a spec, a plan, reviewed code, and a closed plan, with every step on the record.
$/pocketto:pocket-grinding "add dark mode toggle"