archflow

---

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.