The Vibe Code Bible

The ARC Method: Architect, Refine, Check

By Khalel Dumaz · Updated

Quick answer

The ARC Method is the three-pass workflow I use to build software with AI: Architect (plan before any code), Refine (build to the approved plan), and Check (run tests, then review in a fresh session, ideally with a different model). I used it to build Vora IQ, a multi-agent platform for founders. It matches the workflow Anthropic recommends for Claude Code, and published research supports each pass.

The three passes

Pass Job Output Model, as of October 2026
Architect Explore the code and plan the change. No edits. A written plan: files touched, data flow, edge cases, open questions Claude Opus 5.5 at high effort, or Fable 5.1 for hard architecture
Refine Build to the approved plan, with tests. Working code and passing tests Claude Sonnet 5.5, or Opus 5.5 for large changes
Check Run the checks, then review independently. Test results, plus a list of real gaps with file, line, and fix Your test suite first; then a fresh session, ideally a different model (Fable 5.1, or GPT-6.1 Sol from another vendor)
🏛️
The Analogy

You wouldn't ask a bricklayer to design a skyscraper and then sign off on their own work. An architect draws the plan, a builder builds it, and an inspector checks it against the code before anyone moves in.

Why I use it

ARC started as the way I build. I used it to build Vora IQ, a startup operating system for solo founders and early-stage teams, and it worked well. I named the passes so the habit is easy to teach and repeat.

Vora IQ is a multi-agent architecture. As of October 2026 it runs 13 specialized AI agents covering strategy, marketing, finance, legal, and growth, including Echo for social media, Axis for build plans, Vibe for brand messaging, and Insight for market research. Every agent reads and writes one shared Business Context Layer, so an update from one agent reaches the others.

Systems like that are a demanding test for any workflow: agents hand work to each other, so a plan that defines each agent's job and what they share comes before any code, and every change needs a check that the pieces still fit together.

My experience is one builder's results. What follows is the outside evidence for why each pass works, and where its limits are.

The evidence behind each pass

Each pass rests on published guidance or research:

Pass What the evidence says Source
Architect “Letting Claude jump straight to coding can produce code that solves the wrong problem.” Anthropic recommends a four-step loop: explore, plan, implement, commit. Anthropic, Best practices for Claude Code
Architect + Refine Splitting the work between a reasoning model that plans the change and a second model that writes the edits produced the top score on Aider's code-editing benchmark at the time (85%, with o1-preview as the planner). Aider, September 26, 2024
Refine Anthropic recommends giving the agent a check it can run, such as tests or a build, and starting implementation in a fresh session with a written spec, so the context is focused on the build. Anthropic, Best practices for Claude Code
Check “A fresh context improves code review since Claude won't be biased toward code it just wrote.” Anthropic recommends a writer/reviewer split across two sessions. Anthropic, Best practices for Claude Code
Check Models can recognize their own outputs and rate them higher than other text of equal quality. Panickssery, Bowman, and Feng, NeurIPS 2024
Check Without outside feedback, models that tried to correct their own reasoning often failed to improve and sometimes got worse. Huang et al., ICLR 2024
Check, different vendor Across more than 350 models, errors were correlated. Shared providers and architectures were among the drivers, so a reviewer from another vendor adds some independence. Kim, Garg, Peng, and Garg, ICML 2025

What the evidence does not show

When to use the full ARC loop

Change Passes
One-sentence fix (a typo, a log line, a rename) Refine, then run the tests
A feature that touches several files Architect, Refine, Check with tests and a fresh review session
Auth, payments, data access, or anything security-sensitive Full ARC, with a reviewer from a different vendor and a human read of the diff

Prompts for each pass

// ARCHITECT (plan mode, no edits)
"Read the relevant code first. Then plan only, no code: list the files
this feature touches, the data flow, and the edge cases. List anything
ambiguous as a question before I approve the plan."

// REFINE (paste the approved plan)
"Implement this approved plan. Follow CLAUDE.md and the contract files.
Write tests for the new behavior and run them. If the plan is wrong or
incomplete, stop and tell me instead of improvising."

// CHECK (run the tests first, then a new session, ideally another model)
"Review this diff against the plan. Flag only issues that affect
correctness, security, or the stated requirements: logic errors,
unhandled edge cases, and places the code differs from the plan.
Number each issue with file and line. Skip style preferences."

Two ways to run ARC

Setup How it works Best for
One tool, several models Stay in Claude Code. Use plan mode for Architect, switch models with /model, and run Check in a fresh session or a review subagent. Solo builders who want fewer tools
Several tools, one pass each Plan in one tool, build in an editor such as Cursor, review with another vendor's agent such as ChatGPT Codex. Teams already using more than one AI tool

What keeps the three passes aligned

Three passes drift apart unless they share a written source of truth. Contract files do that job: API_CONTRACT.md for endpoints, TYPES_CONTRACT.md for shared types, and STATE_CONTRACT.md for app state. Architect writes them, Refine builds to them, and Check flags any code that differs from them. Your CLAUDE.md holds the project-wide rules all three passes follow.

DON'T SKIP THE HANDOFF: Paste the approved plan into the Refine prompt, or save it to a file the new session reads. A fresh session has no memory of the plan you just approved.

Go deeper: Chapter 1a: The ARC Method in the full guide.

Frequently asked questions

Does the ARC Method work?

It has worked well for me: I used it to build Vora IQ, a platform where 13 specialized AI agents share one business context. Each pass is backed by outside evidence. Anthropic recommends planning before coding and reviewing in a fresh context, and published research shows models favor their own output and rarely fix their own reasoning without outside feedback. No independent study has measured the full workflow yet, so try it on your own work and keep what helps.

Do I need three different AI tools for the ARC Method?

No. You need three separate passes with three different jobs. You can run all three in one tool, such as Claude Code, by switching the model for each pass and starting a fresh session for the review.

When should I skip the Architect pass?

Skip it when the change is small and clear. Anthropic's guidance for Claude Code: if you could describe the diff in one sentence, skip the plan. Planning pays off when the approach is uncertain, the change touches multiple files, or the code is unfamiliar.

Why not let one AI session do everything?

Because a model is a weak judge of its own work. In a NeurIPS 2024 study, models recognized their own outputs and rated them higher than others. In an ICLR 2024 study, models that tried to correct their own reasoning without outside feedback often failed to improve and sometimes got worse. Tests and a fresh reviewer supply that outside feedback.

Does a reviewer from a different AI vendor guarantee independent review?

No. An ICML 2025 study of more than 350 models found that when two models were both wrong, they often gave the same wrong answer, and the most capable models shared errors even across different providers. A second vendor still helps, but run tests first, because tests don't share a model's blind spots.

Sources