Plans vanish into conversation
After enough turns, the real task boundary, acceptance rules, and next action become hard to recover.
For work that lasts longer than one chat
Give long-running AI work a memory.
Use it when one task spans several repos, several review rounds, or several days of experiments. CodeArmy keeps the plan, task status, review results, and next action in repo so the work can stop, resume, and stay understandable.
- Ship one feature across multiple repos with explicit review gates.
- Run a research iteration that includes local edits, cluster jobs, and later wake-ups.
- Hand work from planner to executor to reviewer without re-explaining the whole project.
- See at a glance what is ready, blocked, waiting, or done.
Why CodeArmy
Because chat history is not a durable project system.
When the work is short, chat is enough. When the work stretches across repos, people, and compute surfaces, the state starts to leak. CodeArmy exists to keep that state visible.
Long jobs outlive the operator
Cluster runs, waiting tasks, and delayed checks keep going while the human context goes stale.
Review and rerun evidence scatters
Commits, reviewer verdicts, logs, and follow-up actions end up split across tools and threads.
Multi-repo work loses boundaries
Without explicit scope, it becomes unclear which repo changes belong together and what is blocked.
What CodeArmy Does
It gives long-running work a coordination contract.
The point is not to sound clever. The point is to make the next action obvious, the current state inspectable, and the evidence easy to review.
Turn one objective into reviewable task packages
Plans become phased tasks with dependencies, write scope, and acceptance rules instead of a loose to-do list.
Tell you what is ready, blocked, waiting, or done
Reconcile reads repo truth and derives the queue instead of relying on operator memory.
Keep humans in the approval loop
Plan approval, review verdicts, and reopen policy stay explicit rather than implied.
Run work in isolated execution surfaces
Source repos, worktrees, branches, and remote jobs stay bounded and attributable.
Wake long tasks and continue later
Waiting on training, evaluation, or external evidence no longer means losing the thread.
Write status and reports back to repo
The same artifacts that drive execution also support live reports and final summaries.
Workflow
The loop is simple: define, plan, execute, review, reconcile.
This is the user-facing flow. Each step produces an artifact so the next person or agent can continue without guessing.
Define the objective
Start with a real goal, source repos, and boundaries for this round of work.
campaign.mdPlan and approve
Turn the goal into phases and task packages, then hold plan approval before execution.
plans/ + task packagesExecute in bounded scope
Run the task in isolated repos, branches, worktrees, or jobs with clear ownership.
results/ + commit anchorsReview and write back
Reviewer verdicts, concerns, and follow-up actions are written back where the task lives.
reviews/Reconcile and continue
Refresh the campaign state, surface blockers, and decide the next wave of work.
live-report.mdReal Cases
This is for work that is already messy in real life.
The examples below reflect real campaign patterns around Alice and CodeArmy rather than generic marketing placeholders.
CodeArmy Site Rewrite
Use one campaign to manage positioning, bilingual fixes, content review, and the release of the site itself.
- Content changes and UI fixes are split into explicit tasks instead of chat-driven editing.
- Review verdicts explain why a change was accepted or sent back.
- The campaign can close with a live report that matches the actual repo state.
FastEcalSim Recovery Work
Coordinate local code changes, smoke tests, cluster runs, checkpoint checks, and follow-up wake-ups in one traceable loop.
- Task packages point to worktrees, scripts, checkpoints, and quality gates.
- Blocked state stays explicit when external evaluation evidence is still missing.
- Handover notes remain attached to the same campaign instead of drifting into new threads.
JUNOSW Multi-Repo Tuning
Keep documentation repos, code repos, inherited evidence, and phase gates aligned in a single planning surface.
- Old archive material stays reference-only instead of silently becoming active truth.
- Repository issues and dependency blockers are surfaced by reconcile.
- The next action stays visible without spreadsheets or manual status boards.
Why Repo-First
CodeArmy is repo-first because the repo is where recovery happens.
The chat helps people and agents move. The repo records what actually happened. If the system must survive interruptions, handoffs, and review, the durable state cannot live only in conversation.
- A new agent can restart from repo artifacts without replaying a week of chat.
- Review happens against the same task package that guided execution.
- Reports summarize repo truth rather than replacing it.
- Humans can inspect the exact current state before approving the next step.
What lives in the campaign repo
The structure is intentionally plain text and diff-friendly. It is built for inspection, review, and restart.
campaign.md
plans/proposals/
plans/merged/master-plan.md
phases/Pxx/tasks/Txxx/task.md
phases/Pxx/tasks/Txxx/reviews/R001.md
reports/live-report.md
Quickstart
The shortest path is still repo-first.
If you want to understand CodeArmy quickly, start from a campaign repo and run the control loop once.
Create the campaign shell
Start from a real objective and the repos you want to coordinate.
alice-code-army create
alice-code-army bootstrapScan the repos and boundaries
Make the source repos and execution surface explicit before you dispatch work.
alice-code-army repo-scanRun reconcile
Let the system derive plan state, ready tasks, blocked tasks, and next actions from repo truth.
alice-code-army repo-reconcileApprove, execute, review
Keep the human gate explicit, then write execution and review evidence back to the same campaign.
alice-code-army approve-planIf you are debugging the system itself, read the runtime repo and the campaign repo together: one shows control flow, the other holds the durable state.
CodeArmy
Open-source orchestration should feel inspectable, not mystical.
CodeArmy is strongest when it makes long-running work legible: clear plans, bounded execution, auditable review, and state you can recover after a pause.