Archflow

Turn Claude Code into a structured development team.

Website · Quick Start · Three Ways to Start · Commands · How It Works · Phases · Agents

Getting AI to write code stopped being the hard part. Keeping it coherent is. Sessions end and take their context with them. The frontend drifts from the backend. Two weeks in, nobody can say what's actually finished.

Archflow is a phase-based AI development framework for Claude Code that fixes this structurally, with 17 specialized agents working from product strategy through 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 against that same contract — so they can't quietly disagree. Handoffs happen through files, not chat, so context outlives the session that created it.

Two things keep it practical rather than theoretical:

It meets your codebase where it is. A blank directory, an established codebase, or a prototype that outgrew itself — Archflow reads what already exists and picks up from there. It never assumes you're on day one.

Ceremony scales with the project. A solo weekend build runs in quick mode: one implicit release, gates that record but don't block. A team with a real release pipeline runs in full mode. Same schema either way, so switching costs nothing — and Archflow offers the upgrade when it notices you've outgrown the simpler mode.

Works with any project type — fullstack, frontend-only, backend-only, or mobile — adapting its phases, agents, and artifact structure to each.

claude plugin marketplace add azidan/archflow https://github.com/AZidan/archflow

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.

cd your-project
claude

Then pick the entry point that matches where you actually are.

Whichever you pick, Archflow proposes and waits — every artifact is shown to you before it's written, and no phase advances without your approval. Your code is never modified during setup.

/archflow:init

Creates the state files and drops you at Phase 1. A product-strategist works out who this is for and what success means, a feature-planner turns that into a backlog, and you move through design → API contract → implementation with an approval gate at every step.

Starts in quick mode, so you get structure without ceremony until you ask for it.

📖 Full guide: starting a new project

/archflow:onboard

Dispatches up to 9 agents in parallel to read your codebase, imports context from tools you already use (Jira, Notion, Linear, GitHub, Confluence, Slack), and reverse-engineers the artifacts you never wrote down — design system, API contract, user flows, roadmap. Everything is presented for approval before anything is written.

It also works out which phase your project has reached, so you don't redo work that's already done.

📖 Full guide: onboarding an existing codebase

Your prototype works. People are using it. What it doesn't have is a roadmap, an API contract, a test plan, or a defensible answer to what "1.0" means.

/archflow:onboard

Onboarding audits what you shipped and reconstructs the plan around it. Where it finds working code with no story behind it, it writes the story and marks it delivered — so your roadmap opens reflecting reality instead of pretending nothing exists yet.

From there, the road to a real product is the phases a prototype skips:

You stay in quick mode while it's still small. When Archflow spots growth signals — a second release, a second contributor, a size threshold — it offers full mode with explicit release planning and role-based gates. It never forces the upgrade.

What this does and doesn't do: it gives you the plan, contracts, and quality gates your prototype never had, and Phase 4 agents will review code quality, security, and performance. It will not silently rewrite your architecture. You decide what gets refactored — Archflow makes sure you know what needs it.

📖 Full guide: taking a prototype to production

/archflow:feature          # Interactive wizard
/archflow:feature login    # Quick-add by name or description

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 work.

Capture an idea without committing to it, and detail it later when it's next up:

/archflow:feature          # → capture as a backlog stub
/archflow:groom S2-11      # → add acceptance criteria, subtasks, gates
/archflow:feature S2-11    # → pull it into the active release and start building

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. 17 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.

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.

Most AI workflows assume you're starting from scratch. This is the one that doesn't — and it's the engine behind both the existing codebase and prototype to product paths above.

Phase A: Interactive Collection     Answer 5 questions about your stack and context sources

Phase B: Autonomous Agent Dispatch  Up to 9 agents analyze your codebase in parallel:
                                    codebase audit → doc deep-dive → design extraction →
                                    route/API extraction → product-strategist → ux-designer →
                                    api-contract-architect → dsl-generator → feature-planner

Phase C: Synthesis & Presentation   Artifacts generated and presented for your approval

The onboarding agents generate ready-to-use project-context.md, roadmap.yaml, backlog.yaml, api-contract.md, theme.yaml, styled-dsl.yaml, and user-flows.md — all reverse-engineered from your existing code and imported documentation. It also creates or updates your project's CLAUDE.md with architecture context derived from the analysis.

Two things make the result honest rather than aspirational: reconciliation moves any story whose code already exists into a shipped release, and the gap report tells you plainly what's missing — no tests, no contract, no design system — so you're choosing what to fix rather than discovering it later.

Nine commands, all namespaced /archflow:<name>. You'll use three of them regularly.

Getting set up — run once per project

Day to day — the ones you'll actually type

Planning and pace — when the project grows

Run /archflow:status any time you've lost the thread — it reports where the project stands and what's sensible to do next.

Archflow detects and adapts to your project type:

Phase instructions, agent selection, audit checks, and roadmap structure all adapt to the project type.

Archflow uses a structured branching strategy:

main
 └── feature/user-auth              (feature branch)
      ├── user-auth/login-form       (task branch)
      ├── user-auth/auth-api         (task branch)
      └── user-auth/session-mgmt     (task branch)

• Feature branches from main
• Task branches from the feature branch
• Merges only happen after explicit user approval
• Feature completion triggers cleanup and roadmap updates

Archflow manages these files in your project:

archflow/
├── .claude-plugin/marketplace.json  # Marketplace registry
├── plugin/                          # Installable plugin
│   ├── .claude-plugin/plugin.json   # Plugin manifest
│   ├── hooks/hooks.json             # SessionStart hook (loads instructions after compaction)
│   ├── agents/                      # 17 specialized agent definitions
│   ├── commands/                    # Slash commands (namespaced /archflow:<name>)
│   │   ├── status.md                # /archflow:status
│   │   ├── init.md                  # /archflow:init
│   │   ├── onboard.md               # /archflow:onboard
│   │   ├── migrate.md               # /archflow:migrate
│   │   ├── mode.md                  # /archflow:mode
│   │   ├── release.md               # /archflow:release
│   │   ├── groom.md                 # /archflow:groom
│   │   ├── feature.md               # /archflow:feature
│   │   └── setup-mcp.md             # /archflow:setup-mcp
│   ├── scripts/migrate.py           # v1.0 → v2.0 migration engine (used by /archflow:migrate)
│   └── skills/archflow/             # Framework knowledge + assets copied into projects
│       ├── SKILL.md                 # Overview skill (what Archflow is, where things live)
│       ├── instructions.md          # Core instructions (copied to .archflow/, reloaded via hook)
│       ├── workflow.md              # Git branching strategy
│       ├── phases/                  # Phase-specific instruction files (10 files)
│       ├── schemas/                 # roadmap / release / backlog / history schemas
│       ├── base-dsl-structure.yaml  # DSL template for design artifacts
│       └── mcp-registry.yaml        # Curated MCP server registry
├── README.md
└── LICENSE

your-project/
├── .archflow/                       # Project state (version-controlled)
│   ├── current-phase.yaml           # Phase state tracker
│   ├── project-context.md           # Business goals, tech stack, architecture
│   ├── roadmap.yaml                 # Index: epics, release pipeline, mode
│   ├── backlog.yaml                 # Unscheduled scope (stubs + groomed stories)
│   ├── releases/                    # One file per release; archive/ for shipped
│   ├── history.yaml                 # Shipped ledger (institutional memory)
│   └── current-feature.yaml         # Active feature scope and tasks
├── .claude/settings.json            # Plugin reference (auto-created on install)
└── CLAUDE.md                        # Updated with Archflow section by onboarding

• Claude Code CLI (latest version)
• Git
• Node.js (for some MCP servers)

Contributions are welcome. Areas of interest:

• New agents — Add specialized agents in agents/ following the existing format
• Phase improvements — Refine phase instructions in .archflow/phases/
• MCP registry — Add tool integrations in skills/archflow/mcp-registry.yaml
• Bug fixes — Open an issue or submit a PR

• Bug reports: GitHub Issues
• Feature requests: GitHub Issues
• Questions: GitHub Discussions

MIT License — see LICENSE for details.