Archflow
Turn Claude Code into a structured development team.
Website · Quick Start · How It Works · Phases · Agents · Commands
What is Archflow?
Archflow is a phase-based AI development framework for Claude Code. It orchestrates 16+ specialized agents through a structured workflow — from product strategy to production deployment.
Instead of one AI doing everything, each task goes to an agent with deep expertise in its domain. A product-strategist defines business goals. A ux-designer creates the design system. An api-contract-architect locks down API specs. Then ui-engineer and api-engineer build frontend and backend in parallel — coordinated through file-based handoffs and mandatory approval gates.
Archflow works with any project type — fullstack, frontend-only, backend-only, or mobile — and adapts its phases, agents, and artifact structure accordingly.
Quick Start
1. Add the Marketplace (one-time)
claude plugin marketplace add azidan/archflow https://github.com/AZidan/archflow
2. Install the Plugin
claude plugin install archflow --scope project
This saves the plugin reference to .claude/settings.json in your repo — any team member who clones gets prompted to install automatically.
Free and open source. No lock-in. Uninstall anytime with claude plugin uninstall archflow.
3. Start Your Project
Open Claude Code in your project directory:
cd your-project
claude
- New project? Archflow starts at Phase 1 (Strategy).
- Existing codebase? Run
/archflow onboard— agents analyze your code, import context from your tools, and generate all artifacts for approval.
4. Develop Features
/archflow feature # Interactive wizard
/archflow feature login # Quick-add by name
Archflow creates the feature branch, breaks it into tasks, and guides implementation through the appropriate agents. Features are filtered by scope — a backend_only repo only sees backend-scoped features from the roadmap.
How It Works
Building software with AI means context gets lost, quality varies, and the same mistakes repeat. Archflow fixes this with three ideas:
- Specialized agents — A UX designer doesn't write backend code. An API engineer doesn't make design decisions. 16+ agents, each scoped to one domain.
- File-based handoffs — Context survives between conversations. Agents communicate through artifacts, not chat — so nothing gets lost when a session ends.
- Phase gates — 6 phases from strategy to deployment. Nothing moves forward without your approval. No skipped steps. No autonomous decisions on what ships.
- Contract-first development — API contracts are defined before implementation. Frontend and backend build against the same spec, so they never disagree.
- Focused context — Each phase loads only what the active agents need. Less noise, better results.
- Acceptance testing — Features aren't done until they pass acceptance testing against your roadmap criteria.
The Phases
Phase 1 Strategy & Planning product-strategist, feature-planner
Phase 2 Design ux-designer, dsl-generator
Phase 2.25 High-Fidelity Screens SuperDesign MCP (optional)
Phase 2.5 API Architecture api-contract-architect
Phase 3 Implementation (Parallel) ui-engineer + api-engineer, qa-engineer, pm-maestro-reviewer
Phase 4 Quality & Optimization code-reviewer, performance-optimizer, pm-maestro-reviewer
Phase 5 Launch & Operations devops-engineer, post-launch-analyst
Phase 6 Enhancement (On-Demand) i18n-engineer, post-launch-analyst, any agent as needed
Each phase has explicit completion criteria, expected output artifacts, and requires user approval before advancing.
Works with Existing Projects
Most AI workflows assume you're starting from scratch. Archflow meets you where you are.
Run /archflow onboard and it dispatches up to 9 agents in parallel to deeply analyze your codebase. They import context from tools you already use (Jira, Notion, Linear, GitHub, Confluence, Slack), reverse-engineer your design system and API contracts, and drop you into the right phase based on what already exists.