Documentation
Everything AOForge does, why it does it that way, and how to drive it.
AOForge is a Claude Code plugin that turns a description of what you want into shipped, verified code. It does that by keeping the system complicated so your workflow doesn’t have to be: context engineering, XML-structured prompts, subagent orchestration and durable state all sit behind a handful of commands.
Where to start
If you have never used AOForge, read these three in order. Twenty minutes total.
- Installation — the two-line install and what it registers.
- Quickstart — build something small, end to end.
- Context rot — the problem the whole design answers.
How this site is organised
- Getting started — install, first project, adopting an existing codebase.
- Concepts — the ideas you need to predict what AOForge will do.
- Commands — all 3.1.0-era skills, grouped by what you’re trying to accomplish.
- Architecture — the agents, hooks and plugin layout underneath.
- Configuration —
config.json, model profiles, gates, environment variables. - Guides — task-shaped walkthroughs for GitHub sync, workstreams, UI eval and releases.
- Reference — the
aof-toolsCLI, the.aoforge/file structure, the defaults table, a glossary.
Generated from source
The command, agent, hook and CLI tables on this site are generated from the plugin source at build time byscripts/gen-docs-data.cjs. If a table here disagrees with
your installed version, check which version you have — the tables cannot drift from
the release they were built against.Troubleshooting
The failures people actually hit, and what to do about each.
Contributing
Working on AOForge itself: layout, tests, conventions and the release gate.
Getting started
Install the plugin, run your first objective, and point AOForge at code you already have.
Installation
AOForge ships as a Claude Code plugin. Two lines, no build step, works on macOS, Windows and Linux.
Migrating to AOForge
3.0.0 renamed the plugin and 3.1.0 stopped reading the old names. What moves by itself, what you do, and how to check it.
Quickstart
Ten minutes: initialise a project, plan one objective, build it, verify it.
Your first project
A closer look at what new-project produces, and how to steer it before it commits to a plan.
Existing codebases
Adopting AOForge on code that already exists — map it first, then plan against reality.
Concepts
The ideas behind the commands. Read these and AOForge’s behaviour stops being surprising.
Context rot
The problem AOForge exists to solve, and why the answer is structural rather than a prompting trick.
The loop
Six phases, each writing files the next one reads. What each phase produces and when to skip it.
The .aoforge directory
Every file AOForge creates, who writes it, and who reads it back.
The intent model
kind × work → TDD posture, planning depth, model profile and verification rigor. A spike is not tested like a payments API.
Waves and checkpoints
How independent jobs run in parallel, and the four ways execution can legitimately stop.
State and memory
What survives a /clear, a reboot and a week away — and how to get it back.
Context discipline
Measured guidance on keeping an agent's window small. The lever is behaviour, not configuration.
Commands
Every skill, grouped by what you’re trying to get done. All tables on these pages are generated from the plugin source.
Core workflow
The commands that plan, build and verify. These are the ones you use daily.
Status and navigation
Finding out where you are, what's next, and what everyone else is doing.
Managing the plan
Changing scope mid-milestone: adding objectives, auditing, archiving, and fixing drift.
Advanced execution
Parallel worktrees, chained skills, and handing TTY-bound commands to your own shell.
Integrations and analysis
GitHub sync, strategic initiatives, UI evaluation, security auditing and codebase mapping.
Settings
Changing which agents run, which models they use, and how much the workflow asks you.
Architecture
The agents, hooks and plugin layout that make the commands work.
Agents
The 12 core subagents skills dispatch to, what each is for, and which model tier each runs at.
Hooks
How AOForge turns advisory rules into enforced ones — and every documented way out.
Plugin layout
Where everything lives in the repository, and how the pieces reference each other.
Configuration
config.json, model profiles, gate severity, and every environment variable.
config.json
The full workflow configuration schema, field by field, with the defaults AOForge ships.
Model profiles
Three profiles map every agent onto a model tier. What each costs, and why budget isn't Haiku everywhere.
Gates and enforcement
Which gates block, which merely ask, how to tune each, and how to log an override rather than hiding it.
Environment variables
Every AOFORGE_ variable, what it changes, and the Claude Code variables worth leaving alone.
Guides
Task-shaped walkthroughs for the parts of AOForge you opt into.
GitHub integration
Mirror planning state to issues, milestones and releases. One-way — planning files stay the source of truth.
Parallel workstreams
Running whole objectives concurrently in git worktrees, then merging them back.
The handoff watcher
A local daemon that runs TTY-bound commands in your shell so Claude never has to stop and ask.
Design craft
Seven references that give AOForge's design skills taste: reading a brief, tuning dials, a catalogue of generated-look patterns, a …
UI evaluation
Machine-judged visual correctness — capture each declared UI state, score it offline, gate verification on the result.
Telemetry and auditing
Measuring where context goes, where agents get blocked, and whether gates are earning their friction.
Changelog and releases
Generating Keep-a-Changelog entries from conventional commits, and the gate that stops an undocumented release tag.
Reference
The CLI surface, the file structure, and the vocabulary.