SELF PACED COURSE

The ARCUS
Team

Seven teammates who take your story from a rough idea to a reviewed pull request. Get onboarded, no prior reading required.

ROSTER

Meet the ARCUS team

one team, seven jobs

Lucie — Lead

LucieI run the board — every ticket, every checkpoint, lean or thorough, gated or AFK. I'm the only one who sees the whole roadmap.

Angelina — Architect

AngelinaIn thorough mode I read the codebase, ground every ambiguity, and hand back a whole stack of artifacts. In lean mode, the planner hands back one compact plan worth building.

Quinn — QA

QuinnBefore a line of code exists, I've already found every edge case that's going to bite you.

Diana — Developer

DianaHand me one ticket in a sealed room and I'll build it, test it, and clean it up. Give me three tickets and you get three of me.

Steffi — Staff Engineer

SteffiI read the whole diff, brutal in the hunt — but I'm fair in the verdict. One real nit never blocks a clean change.

Benny — Build Bot

BennyBEEP. TESTS. BUILD. SECRETS. NO OPINIONS. JUST FACTS.

Genie — Guide

GenieI'm not on the board — I'm the one who explains the board. Ask me "where am I" or "what's this fact card mean" any time. That's my whole job, and I'll be narrating the rest of this issue.

PROLOGUE

The team's toolkit

how the team actually works

Exhibit A — the shared notebook

AngelinaFive files under .context/ are the whole team's shared notebook: what this codebase does, how it's laid out, how the flows run, how it's tested, and the patterns worth copying. I write it once and never re-learn the codebase from scratch.

GenieAGENTS.md is just the index card taped to the notebook's cover — it points any teammate at the right page for the job at hand. CLAUDE.md is one line: @AGENTS.md. One notebook, every host reads it.

Exhibit B — you can call anyone by name

GenieA skill is a teammate you can ring directly — name them, like repo-agentifier, or just describe what you want and the right person answers. It lives in plugins/arcus/skills/<name>/SKILL.md and joins the conversation the moment you call it.

Exhibit C — some teammates you never call yourself

LucieAn agent never sits in the main meeting — no one types a trigger for it. I loop it in by name, it works alone in its own room, and reports back a summary. Lives flat in plugins/arcus/agents/<name>.md.

Exhibit D — teammate vs specialist, side by side

Skill — you can call them

User and Lucie can ring them, by bare name: repo-agentifier
Joins the main conversation directly
8 of ARCUS's 26 jobs are called this way

Agent — only looped in by name

Never a trigger a person types themselves
Works alone, in its own space
18 of ARCUS's 26 jobs work this way

GenieYou can ring Angelina yourself to ground a spec. You'd never ring the security specialist directly — Steffi loops that one in herself, during review.

Exhibit E — the office is ready before anyone sits down

GenieA hook isn't a teammate anyone calls — it's wired into the building itself and fires on its own event. In both Claude Code and Copilot CLI, bootstrap.sh runs on SessionStart before anyone says a word. Copilot CLI runs it from the plugin's own install directory though, not the session's — so it reads the real one off the hook's own payload. Either way Lucie never relies on the hook alone: she re-stages the toolbox herself at the top of every run.

Exhibit F — the whole team, in one crate

LucieARCUS: Any Repository Can Use Spec-driven development. arcus-plugin is the crate the whole team ships in — skills, agents, scripts, one bootstrap hook, one version. The arcus marketplace is where you add it from. Same crate works in Claude Code, VS Code, Copilot CLI, and OpenCode.

CH. 0

Day one

Angelina walks the codebase · run once per repo

A brand new codebase. No notebook yet.

AngelinaFour thousand files and not one of them explained to me yet. Before the team takes a single ticket, I need to know this codebase cold.

Four passes, done together, not one at a time

AngelinaFour passes at once, not queued one after another: what the repo does, how the business flows run, how it's tested, what patterns repeat. Nobody waits on anybody.

Day one complete. Once per repo — or when it's gutted.

AngelinaEvery later stage reads this. I only redo the whole scan after a major restructure or a tech-stack change — day to day, a small sync keeps it honest for free.

CH. 1

The thorough brainstorm

Angelina grounds the spec · thorough profile · Gate A

A ticket lands on the board

Lucie"arcus story.md" and it's on the board — the lean planner takes it from here. Add --thorough when you want the old full pipeline.

A compact pack, not the whole notebook

AngelinaI never hand a story the whole notebook — just the compact slice it actually needs. A quick first pass, plain inputs in, one bundle out.

Every open question, handed over in one go

AngelinaI never actually stop and chat. I always decide everything myself, then jot the calls I was least sure about into an Open Questions list — each with exactly one recommended option and a one-line reason. In gated mode Lucie hands you that whole list at once, so you answer in a single reply, in your own words if you like. In AFK mode nobody reads it and my picks just stand.

Two documents come out the other side

Angelinagrounded-spec.md is every resolved ambiguity and its acceptance criteria. plan.md is the atomic ### Task N: list. Gate A: say "yes", or come back later with generate test plan for <STORY>.

INTERLUDE

Lucie's profiles and modes

two profiles, three modes — lean by default · --thorough when you need it

Careful Lucie — gated mode

LucieLean + gated is my default. I stop after the planner's plan.md, then build, run Benny's deterministic gate, and send one reviewer. Add --thorough when you want the full 5.x ceremony and its phase gates.

Middle Lucie — intelligent mode

LucieIntelligent is my cloud mode. The profile still decides lean or thorough; this mode only decides where I pause. I skip phase-boundary gates and run unattended from CI.

Turbo Lucie — AFK mode

LucieAutonomous (AFK) is the same me, no brakes. Trigger with forge, afk, run afk on <STORY>, or arcus <STORY> --afk — whichever profile you chose runs back-to-back, milestones only.

CH. 2

Quinn finds the edges first

Quinn designs the test matrix · Gate B

Before a single line of code — the test matrix

QuinnHappy path, boundary conditions, and every way this could fail — designed before code exists, following whatever .context/testing-patterns.md already established. That's TDD, not an afterthought. Gate B: arcus <STORY> when you're happy with the matrix.

CH. 3

Diana, times three

Diana takes the tickets · Gate C

The branch didn't exist until now

LucieDay one only planned the branch name — no git branch existed yet. Only now, at the start of Implementation, do I actually create arcus/<STORY>-N, re-checking for name collisions since day one. Planning stays entirely on the base branch; we only branch once there's real code to commit. Unless the room I woke up in already had a door — see the card below.

Every ticket, its own sealed room

DianaLucie parses every ### Task N: heading. Small lean plans get TDD in-thread; larger ones send one compact copy of me per task. Thorough mode adds the old dispatcher, tidy-up pass, and advisory spec check.

CH. 4

Benny, then Steffi

Benny's gate → Steffi's review · Gate D

Tier 1 — no nuance, no negotiating

BennyI run the repo's real tooling — never a model eyeballing the diff. Any hard block on typecheck, tests, build, or a leaked secret ends it immediately: no review from Steffi, straight to changes_requested. Lint and format get auto-fixed and committed where possible.

Tier 2 — five checklists, only if Benny lets it through

SteffiSpec compliance and code quality look at the whole diff holistically; security and performance hunt concrete regressions; the history lens catches load-bearing complexity someone quietly deleted. That last one skips docs-only diffs and shallow history.

The verdict — and the round that resets, but not forever

changes_requested→fix-tasks appended to plan.md→back to Diana→re-review→ up to 3× →approved→notebook sync → PR

SteffiNo review round resets forever. Lean is bounded to 2 rounds; thorough keeps 3. Still failing at the cap, and it stops for a human — a loop that never ends helps nobody.

LucieLean starts with Benny's deterministic gate, then sends one change-reviewer. Security and performance specialists join only when risk flags them; thorough keeps the five-specialist review.

CH. 5

Notebook sync

Angelina syncs the notebook → Lucie ships

Only the pages that actually changed get synced

AngelinaI assess the approved diff. Lean asks Benny's drift check first and syncs only on structural change; thorough updates only the notebook pages materially touched. No full rewrite.

The ticket ships

LucieNotebook sync moves straight into Closure. Lean writes the PR body in-thread and runs pr.sh; thorough synthesizes it with the pull-request-builder.

ADVANCED

Ask one teammate alone

you don't need the whole team

Just Angelina, no ticket, no board

AngelinaYou've never run ARCUS, no notebook, no checkpoint, no branch. You can still ask me directly with a plain sentence and get back resolved ambiguities and acceptance criteria. No ARCUS filename ever enters the conversation — just plain, ordinary language.

Pin-up page: how to talk to the team

Say this	You get
"agentify this repo" / `repo-agentifier`	Once per repo. Angelina scans in parallel, writes the notebook, pins up `AGENTS.md` + `CLAUDE.md`.
`plan <STORY>` or `arcus <STORY>`	Gated, the default. Lucie stops for open questions and phase-boundary gates.
`arcus <STORY> --intelligent`	Intelligent, cloud mode. Lucie stops for open questions only, no phase-boundary gates.
`forge <STORY>` / `afk <STORY>` / `run afk on <STORY>` / `arcus <STORY> --afk`	Autonomous (AFK), no gates. Every stage back-to-back, milestone-only output.
`generate test plan for <STORY>`	Cold-resume into Quinn's Test Plan at Gate A.
`review <STORY>`	Cold-resume into Steffi's Code Review at Gate C.
`sync context`	Standalone notebook sync, outside the board.
`create pull request for <STORY>`	Cold-resume into Lucie's Closure.
`resume <STORY>`	Continue from the first incomplete stage, in whatever mode the checkpoint remembers.
"where am I" / "arcus help"	Genie — the always-on help desk.

Every fact in this issue is lifted from the skills and docs themselves — pipeline.md, modes.md, capability-library.md, context-engineering.md, and the SKILL.md frontmatter. To be continued in your repo. 🧑‍💻