The most advanced toolkit for generating production-grade code with Claude Code. 18 parallel code reviewers. Working memory that never forgets. Self-learning that gets smarter every session.

Claude Code is powerful. DevFlow makes it extraordinary.

18 parallel code reviewers. Not a linter. Not a single-pass review. DevFlow deploys up to 18 specialized reviewers simultaneously: security, architecture, performance, complexity, consistency, regression, tests, plus conditional reviewers for TypeScript, React, accessibility, Go, Python, Java, Rust, database, dependencies, and documentation. Each reviewer has domain-specific expertise. Findings include confidence scores, and false positives are tracked and penalized.

Working memory that never forgets. Three shell hooks preserve session context across restarts, /clear, and context compaction. Zero ceremony. Your AI remembers what it was doing, what decisions were made, and what files were modified. Every session picks up exactly where the last one left off.

Long-term project knowledge. Architectural decisions (ADRs) and known pitfalls persist across sessions in .memory/knowledge/. Reviewers automatically check if changes reintroduce known pitfalls or violate prior architectural decisions.

Self-learning workflows. DevFlow watches how you work and auto-creates slash commands and skills from repeated patterns. It literally gets smarter the more you use it, detecting workflow patterns across sessions and generating reusable artifacts.

39 quality skills. 10 shared agents. Full lifecycle from specification to PR. One npx devflow-kit init.

• 18 parallel code reviewers with security, architecture, performance, complexity, consistency, regression, tests, plus conditional language and framework reviewers
• Working memory that survives restarts, /clear, and context compaction. Zero ceremony.
• Self-learning that detects repeated workflows and auto-creates slash commands and skills
• Long-term project knowledge with architectural decisions and known pitfalls that persist and inform reviews
• Full-lifecycle implementation from spec to explore to plan to code to validate to refine in one command
• Parallel debugging with competing hypotheses investigated simultaneously
• 39 quality skills with 9 auto-activating core, 8 language/ecosystem, plus specialized review and orchestration skills
• Ambient mode that classifies intent and loads proportional skill sets automatically
• Model strategy with explicit model assignments — Opus for analysis agents (reviewer, scrutinizer, shepherd), Sonnet for execution agents (coder, resolver, simplifier), Haiku for I/O agents (git, synthesizer, validator)
• Fully composable plugin system where every feature is a plugin. Install only what you need. No bloat, no take-it-or-leave-it bundles.

npx devflow-kit init

Then in Claude Code:

/code-review

Guides you through defining a feature with three mandatory gates:

1. Understanding Gate - Confirm the feature idea is understood
2. Scope Gate - Validate priorities and boundaries
3. Acceptance Gate - Confirm success criteria

Creates a GitHub issue with well-defined requirements ready for /implement.

Executes a single task through the complete development lifecycle:

1. Exploration — analyze codebase for relevant patterns and dependencies
2. Planning — design the implementation approach
3. Implementation — write code on a feature branch
4. Validation — run build, typecheck, lint, and tests
5. Refinement — simplify and review for quality
6. Alignment Check — verify implementation matches the original request

Creates a PR when complete.

Multi-perspective code review with specialized reviewers:

• Core: Security, Architecture, Performance, Quality
• Conditional (activated when relevant): TypeScript, React, Accessibility, Go, Python, Java, Rust, Database, Dependencies, Documentation
• Findings classified as must-fix, should-fix, or nit with severity and confidence levels

Provides actionable feedback with specific file locations and suggested fixes.

Investigates bugs using competing hypotheses:

1. Hypothesis Generation — identify 3-5 plausible explanations
2. Parallel Investigation — each hypothesis investigated independently
3. Evidence Evaluation — hypotheses ranked by supporting evidence
4. Root Cause — the best-supported explanation with fix recommendation

Produces a root cause analysis report with confidence level.

Processes issues from /code-review:

• Validates each issue is real (not false positive)
• Standard fixes applied directly, careful fixes (public API, shared state) get test-first treatment
• Only defers to tech debt when complete architectural overhaul is needed

The devflow-core-skills plugin provides quality enforcement skills that activate automatically:

Optional plugins for language-specific patterns. Install only what you need:

# Install specific language plugins
npx devflow-kit init --plugin=typescript,react
npx devflow-kit init --plugin=go

• Claude Code (latest)
• Node.js 18+

npx devflow-kit init

The interactive wizard walks through plugin selection, feature configuration (ambient mode, working memory, HUD, safe-delete), and security settings. In user scope, it discovers all projects Claude has worked on and batch-installs .claudeignore across them.

# List available plugins
npx devflow-kit list

# Install specific plugin(s)
npx devflow-kit init --plugin=implement
npx devflow-kit init --plugin=implement,code-review

• --scope user (default) - Install for all projects (~/.claude/)
• --scope local - Install for current project only (.claude/)

DevFlow automatically preserves session context across restarts, /clear, and context compaction — zero ceremony required.

Three shell hooks run behind the scenes:

Working memory is per-project — scoped to each repo's .memory/ directory. Multiple sessions across different repos don't interfere.

DevFlow detects repeated workflows and procedural knowledge across your sessions and automatically creates slash commands and skills.

A background agent runs on session end, batching every 3 sessions (5 at 15+ observations) to analyze transcripts for patterns. When a pattern is observed enough times (3 observations with 24h+ temporal spread for both types), it creates an artifact:

• Workflow patterns become slash commands at .claude/commands/self-learning/
• Procedural patterns become skills at .claude/skills/{slug}/

Observations accumulate in .memory/learning-log.jsonl with confidence scores and temporal decay. You can edit or delete any generated artifacts — they are never overwritten.

DevFlow creates project documentation in .docs/ and working memory in .memory/:

.docs/
├── reviews/{branch}/         # Review reports per branch
└── design/                   # Implementation plans

.memory/
├── WORKING-MEMORY.md         # Auto-maintained by Stop hook
├── backup.json               # Pre-compact git state snapshot
├── learning-log.jsonl        # Learning observations (JSONL)
├── learning.json             # Project-level learning config
├── .learning-runs-today      # Daily run counter
├── .learning-session-count   # Session IDs pending batch (one per line)
├── .learning-batch-ids       # Session IDs for current batch run
├── .learning-notified-at     # New artifact notification marker
└── knowledge/
    ├── decisions.md           # Architectural decisions (ADR-NNN, append-only)
    └── pitfalls.md            # Known pitfalls (area-specific gotchas)

~/.devflow/logs/{project-slug}/
├── .learning-update.log      # Background learning agent log
└── .working-memory-update.log # Background memory updater log

/specify     # Define the feature with clarification gates
/implement   # Execute the full lifecycle

/debug "login fails after session timeout"
/debug #42   # Investigate from GitHub issue

/code-review      # Multi-perspective code review
/resolve     # Fix low-risk issues, defer high-risk to backlog

Session context is saved and restored automatically via Working Memory hooks — no manual steps needed.

Override any DevFlow skill with your own version. Shadowed skills survive devflow init — they won't be overwritten on reinstall or upgrade.

# Create a personal override (copies current version as reference)
npx devflow-kit skills shadow core-patterns

# Edit your override
vim ~/.claude/skills/core-patterns/SKILL.md

# List all overrides
npx devflow-kit skills list-shadowed

# Remove override (next init restores DevFlow's version)
npx devflow-kit skills unshadow core-patterns

Skim optimizes what your AI sees. DevFlow enforces how it works. Backbeat scales everything across agents. No other stack covers all three.

git clone https://github.com/dean0x/devflow.git
cd devflow
npm install
npm run build
node dist/cli.js init

MIT