flowstate

Flowstate

A Claude Code plugin that combines strict development discipline with compounding knowledge. Every cycle produces working code and accumulated insights that make the next cycle easier.

Philosophy

Flowstate is inspired by ideas from several sources:

• Superpowers — TDD enforcement, guided brainstorming, worktree isolation
• Compound Engineering — Knowledge persistence, parallel multi-agent review, plan deepening
• Anthropic's prompting research — Enforcement spectrum, progressive disclosure, context engineering, anti-rationalization patterns

None of these alone delivered what we wanted: strict development discipline and knowledge that compounds across sessions. Flowstate takes the ideas we liked from each and builds its own opinionated workflow.

The Workflow

    ┌───────────────────────────────────────────────────────────────┐
    │                                                               │
    │  brainstorm → write-plan → [deepen] → work → review → compound
    │       ▲                       ▲                           │
    │       │                       │                           │
    │       └───────────────────────┴───────────────────────────┘
    │              knowledge feeds back into
    │           planning, reviewing, and building
    └───────────────────────────────────────────────────────────────┘

Step	Command	What It Does
1	/workflow:brainstorm	Guided design — one question at a time, explore approaches, validate decisions
2	/workflow:write-plan	Research agents + TDD implementation plan with exact file paths and test steps
3	/workflow:deepen-plan	(optional) Per-section parallel research to add depth, examples, edge cases
4	/workflow:work	Worktree isolation → subagent-per-task TDD → two-stage review → ship. Supports wave-based parallel execution via team agents when plan tasks declare depends_on dependencies.
5	/workflow:review	5 parallel review agents (security, performance, simplicity, architecture, patterns)
5b	/workflow:deep-review	Extended 14+ agent swarm with conditional reviewers
6	/workflow:compound	Capture learnings to docs/solutions/ — searchable by future sessions
	/workflow:debug	6-step systematic debugging with 3-strike escalation
	/workflow:setup	Show workflow pipeline, commands, and getting-started guide
	/workflow:remind	Re-inject core rules when Claude drifts from the workflow

Every command can be used independently or as part of the full loop.

Architecture

┌─────────────────────────────────────────────────────────┐
│                    COMMANDS (orchestrators)              │
│  brainstorm · write-plan · deepen-plan · work · review ·│
│  deep-review · compound · debug · setup · remind        │
│                         │                               │
│                    invoke ▼                              │
│              ┌──────────────────────┐                    │
│              │   SKILLS (16)        │                    │
│              │   Process knowledge  │                    │
│              │   HOW to do things   │                    │
│              └──────────────────────┘                    │
│                         │                               │
│                    dispatch ▼                            │
│              ┌──────────────────────┐                    │
│              │   AGENTS (10)        │                    │
│              │   Expert personas    │                    │
│              │   WHO does what      │                    │
│              └──────────────────────┘                    │
│                         │                               │
│                    enforced by ▼                         │
│              ┌──────────────────────┐                    │
│              │   HOOKS              │                    │
│              │   Session start:     │                    │
│              │   core rules always  │                    │
│              │   in context         │                    │
│              └──────────────────────┘                    │
└─────────────────────────────────────────────────────────┘

Commands are lean orchestrators (~8 lines each) that sequence skill invocations. Skills contain all process knowledge — reusable, discoverable, independently invocable. Agents are expert personas dispatched by skills for parallel work. Hooks inject core rules (TDD, verification, brainstorm-before-build) into every session via additionalContext.

The Compounding Flywheel