GitHub - DanMcInerney/architect-loop: Claude Fable 5 as architect, GPT-5.5 Codex as builder, the repo as memory - a research-backed Claude Code skill for the cross-vendor agent loop · GitHub

Open Original Page

GitHub - DanMcInerney/architect-loop: Claude Fable 5 as architect, GPT-5.5 Codex as builder, the repo as memory - a research-backed Claude Code skill for the cross-vendor agent loop · GitHub

Sign in




Appearance settings

Platform AI CODE CREATION GitHub CopilotWrite better code with AI

GitHub Copilot appDirect agents from issue to merge

MCP RegistryNewIntegrate external tools

DEVELOPER WORKFLOWS ActionsAutomate any workflow

CodespacesInstant dev environments

IssuesPlan and track work

Code ReviewManage code changes

APPLICATION SECURITY GitHub Advanced SecurityFind and fix vulnerabilities

Code securitySecure your code as you build

Secret protectionStop leaks before they start

Solutions BY COMPANY SIZEEnterprises

Small and medium teams

BY USE CASEApp Modernization

BY INDUSTRYHealthcare

Resources EXPLORE BY TOPICAI

Software Development

EXPLORE BY TYPECustomer stories

SUPPORT & SERVICESDocumentation

Open Source COMMUNITY GitHub SponsorsFund open source developers

PROGRAMSSecurity Lab

Maintainer Community

Enterprise ENTERPRISE SOLUTIONS Enterprise platformAI-powered developer platform

AVAILABLE ADD-ONS GitHub Advanced SecurityEnterprise-grade security features

Copilot for BusinessEnterprise-grade AI features

Premium SupportEnterprise-grade 24/7 support

Search or jump to...

Search code, repositories, users, issues, pull requests...

Use saved searches to filter your results more quickly

You signed in with another tab or window. Reload to refresh your session.
You signed out in another tab or window. Reload to refresh your session.
You switched accounts on another tab or window. Reload to refresh your session.

DanMcInerney

/

architect-loop

Notifications
You must be signed in to change notification settings

Security and quality
0

Additional navigation options

Security and quality

DanMcInerney/architect-loop

Code Open more actions menu

NameNameLast commit message

Repository files navigation

Claude Fable handles planning and review; GPT-5.5 Codex handles
implementation and research. Two Claude Code skills wire that split into a
repo-centered loop: specs and gates are written first, Codex works in fresh
contexts, and Fable reviews the evidence before anything is integrated. It runs
on the subscriptions you already have - no API keys required by default.

Install (30 seconds)

git clone https://github.com/DanMcInerney/architect-loop
cd architect-loop && ./install.sh # Windows: .\install.ps1
npm i -g @openai/codex@latest # the builder (Codex CLI >= 0.133)

./install.sh --project installs to the current repo only instead of
globally. You need Claude Code on any paid
plan and the Codex CLI signed into a ChatGPT plan.

/architect # the build loop
/architect-research <what you're considering> # the research loop

/architect runs one work block: judge the last run, spec the next slice,
dispatch builders. /architect-research is for when you're still deciding
what to build - its cited report feeds the build loop's PRD.

One short Fable session per work block - judgment only, it never writes code:

Spec + gates first. Fable specs a one-PR slice, splits it into 1-4
lanes whose file sets are checked for overlap, and commits the acceptance gates to
docs/gates/ before any builder starts. Gates are read-only; a builder
edit to a gate file fails the slice automatically.

Parallel isolated builders. One fresh codex exec (xhigh) per lane,
each in its own git worktree. Builders must argue with the spec before
building (silent compliance = defect), build only their declared files,
and report raw results - they do not have commit access in the sandbox.

Fable judges and integrates. It runs the gate commands itself (builder
claims are hearsay), reads the diff against the spec's intent (passing
tests ≠ mergeable work), then commits and merges passing lanes. Judgment
happens in a fresh session because the cited evidence favors fresh-context
review.

The repo is the only memory. docs/HANDOFF.md (a short table of
contents, pruned every session), docs/gates/, docs/lanes/, git
history. Not in the repo = didn't happen.

Supervision built in. Liveness checks on dispatched runs, stall triage
(diagnose the child process tree, kill the narrowest thing), explicit
timeouts on every long command.

Scout-first, like the production deep-research systems - no fixed lane
taxonomy:

A cheap Codex scout maps the topic (~10 searches): canonical
terminology, the load-bearing systems and papers, the named people, the
topic's natural fault lines. Skipped for comparisons and fact-finds.

Fable designs 3-6 topic-specific lanes from the scout's map, drawing
per-source-class tactics from a library (academic citation snowballing,
dependents-not-stars repo evidence, emerging-vs-hype gating, production
pattern mining, expert tracking) - checked for overlap and gaps before
dispatch.

Parallel Codex researchers run under hard budgets: search caps, ≤5
subjects per lane, saturation stop, strict findings discipline (URL + date

quote + confidence tag; NOT FOUND beats inference; no recommendations).
Expert opinion runs as a second wave, roster-seeded by the first.

Fable verifies and writes. ≥2 independent sources per load-bearing
claim, adversarial falsification searches, citations only from URLs
actually fetched - then one author writes one decision-oriented report.
Gathering parallelizes; synthesis never does.

Each design choice is source-backed (full citations in
DESIGN.md):

Weak planners hurt more than weak executors - so the architect model does
the design, and builders get explicit specs.

Links

Browse another page: