By c-reichert
Enforce TDD discipline across the full development lifecycle with multi-agent planning, implementation, code review, and learning capture. Orchestrates parallel subagents for brainstorming, plan generation, isolated worktree execution, extended code reviews, and solution documentation to compound knowledge and prevent repeated mistakes.
Start a guided design session. Explores requirements through one-at-a-time questions, proposes approaches, and produces a validated design document. Use before any implementation work.
Capture learnings from the current work cycle. Documents what worked, what didn't, and how to prevent similar issues. Stores in docs/solutions/ for future sessions.
Systematic debugging with 6-step protocol: reproduce, isolate, diagnose, fix, verify, compound. 3-strike escalation.
Extended review with 14+ agents including conditional and language-specific reviewers. Use for large changes, architectural shifts, or when standard review isn't thorough enough.
Enhance an existing plan with parallel research agents per section. Adds best practices, edge cases, code examples, and learnings references. Does not rewrite — only enriches.
Searches external sources for industry standards, best practices, and real-world examples relevant to a feature or technical decision. Use when local context is insufficient or the work involves high-risk areas like security, payments, or external APIs.
Looks up framework and library documentation using Context7 MCP for accurate, version-specific API details and code examples. Use when implementation involves specific framework APIs, library methods, or version-dependent behavior.
Searches docs/solutions/ for relevant past solutions using grep-first filtering on YAML frontmatter. Use before implementing features or fixing problems to surface institutional knowledge and prevent repeated mistakes. This is the most critical agent for the compounding flywheel.
Scans codebase for existing patterns, conventions, and similar implementations. Use before planning or implementing features to understand the current codebase landscape.
Analyzes feature specifications to map user flows, identify missing error handling, surface edge cases, find ambiguities, and validate acceptance criteria. Use during planning to catch gaps before implementation begins.
Use before any creative work — features, components, changes, or modifications. Guides structured design through collaborative dialogue before implementation. Triggers: "brainstorm", "design", "think through", "explore approaches", ambiguous requests, or requests with multiple valid interpretations.
Use after a problem has been solved and the solution verified working — captures the lesson as categorized documentation in docs/solutions/ with YAML frontmatter so future sessions can find it. Triggers: "compound", "capture learning", "document solution", "that worked", "it's fixed", "working now", "problem solved", "that did it", "doc-fix".
Use for extended multi-agent review with 14+ agents including conditional and language-specific reviewers. Appropriate for large changes, architectural shifts, migrations, or when standard review is not thorough enough. Triggers: "deep review", "thorough review", "full review", "extended review", "review everything", "maximum coverage".
Use to review brainstorm or plan documents before proceeding to the next workflow step. Applies structured self-review for completeness, clarity, consistency, feasibility, and YAGNI.
Use when implementation is complete and all tests pass — guides branch completion by presenting structured options for merge, PR, or cleanup.
Uses power tools
Uses Bash, Write, or Edit tools
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
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.
Flowstate is inspired by ideas from several sources:
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.
┌───────────────────────────────────────────────────────────────┐
│ │
│ 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.
┌─────────────────────────────────────────────────────────┐
│ 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.
npx claudepluginhub c-reichert/flowstate --plugin flowstateHarness-native ECC operator layer - 67 agents, 271 skills, 92 legacy command shims, reusable hooks, rules, selective install profiles, and production-ready workflows for Claude Code, Codex, OpenCode, Cursor, and related agent harnesses
Comprehensive skill pack with 66 specialized skills for full-stack developers: 12 language experts (Python, TypeScript, Go, Rust, C++, Swift, Kotlin, C#, PHP, Java, SQL, JavaScript), 10 backend frameworks, 6 frontend/mobile, plus infrastructure, DevOps, security, and testing. Features progressive disclosure architecture for 50% faster loading.
Access thousands of AI prompts and skills directly in your AI coding assistant. Search prompts, discover skills, save your own, and improve prompts with AI.
Upstash Context7 MCP server for up-to-date documentation lookup. Pull version-specific documentation and code examples directly from source repositories into your LLM context.
Complete developer toolkit for Claude Code
Core skills library for Claude Code: TDD, debugging, collaboration patterns, and proven techniques