AIWG Framework

You hit the wall around week three.

The first sprint with Claude Code or Cursor is magic. Boilerplate evaporates, components materialize, you ship a feature in an afternoon that would have taken a week.

Then the project gets bigger. The third feature contradicts a decision the agent made in the second. The test suite drifts away from what the code actually does. You re-explain the architecture every morning because the context window doesn't remember yesterday. The agent suggests a refactor that breaks something it built last Tuesday.

Anthropic's own engineering blog calls this context engineering — the discipline of curating what the model sees so it can reason about a project that doesn't fit in any one window. AIWG is what the discipline looks like when it's wired into your toolchain instead of done by hand.

Every AIWG project has an .aiwg/ directory that grows alongside the code. It is plain markdown, version-controlled, human-readable, and built to last longer than any one chat session.

.aiwg/
  intake/             project intake forms
  requirements/       use cases, NFRs, acceptance criteria
  architecture/       SAD, ADRs, diagrams
  planning/           phase plans, iteration plans
  risks/              risk register and mitigation
  testing/            test strategy, plans, results
  security/           threat models, security artifacts
  quality/            code reviews, retrospectives
  deployment/         deployment plans, runbooks
  team/               team profile, agent assignments
  reports/            generated reports and indices

Agents read this directory before working. A new chat session is not a fresh slate — it is an agent loading the same memory the previous one wrote to. The requirements analyst writes use cases. The architecture designer reads them. The test engineer reads both. The synthesizer merges everyone's review.

Cross-references use @-mentions: @.aiwg/requirements/UC-001-login.md, @.aiwg/architecture/sad.md. Agents follow the references as deep as they need to and no deeper. The artifact index (aiwg index) makes lookups one-shot more often than not — the agent reaches for the right file instead of browsing six.

When the agent generates broken code, the default reaction in most tools is to ask you what to do next. AIWG's Agent Loop reaches a different conclusion: try, verify, learn from the failure, adapt, retry.

The closed-loop pattern runs locally for short tasks. External Ralph survives crashes — checkpoints state to disk and resumes the loop after the process dies, the network drops, or the laptop sleeps. It will run for six to eight hours autonomously on the right kind of task. Debug memory accumulates failure patterns so the loop doesn't repeat the same mistake twice.

aiwg ralph --attach reattaches you to a running loop's output from any terminal — useful when the loop has been running for an hour and you want to peek without disturbing it.

Daemon mode is what runs while you sleep. A persistent supervisor with a web UI, scheduled tasks, multi-room messaging integrations (Telegram, Discord), cross-session memory, and an autonomous engine that picks up work from a queue.

Combined with Mission Control, you can dispatch parallel background agent loops as named missions and watch them in a live dashboard:

The completion criterion is enforceable, not aspirational — the daemon won't mark the mission done until the criterion is met. Vague conditions ("good enough", "comprehensive") are rejected at definition time per the vague-discretion rule.

You may already use one of these. They're good. They solve different problems.

SuperClaude — A focused command/agent kit for Claude Code. ~22.6k stars at last check. Excellent if you want a curated set of slash commands and you're staying inside Claude Code for everything.

SuperClaude wins when: you want quick, opinionated, single-platform agent kits for short focused tasks.

AIWG wins when: you need persistent memory across sessions, full-SDLC scope (intake through hypercare), and the same agents working the same way across Claude Code, Codex, Copilot, Cursor, Factory AI, Hermes, OpenCode, OpenClaw, tinyhumans.ai, Warp, and Windsurf.

claude-flow — ~41.7k stars. Vector memory with HNSW, swarm orchestration, federation. Strong tactical orchestration story for Claude Code specifically.

claude-flow wins when: you want vector-search memory and swarm orchestration native to Claude Code.

AIWG wins when: you want structured, human-readable, version-controlled .aiwg/ memory you can git diff and audit, plus identical-form portability across the 11 supported AI coding platforms your team uses.

If your project lives entirely inside one tool and lasts a week, the lighter alternatives are probably right. If it spans tools, sessions, or weeks, the structure pays for itself fast.

# 1. Install the CLI

# 2. Deploy SDLC into your project

# 3. Generate intake from your existing code or describe a fresh project

# 4. Start the lifecycle

From there: /flow-concept-to-inception → /flow-inception-to-elaboration → iterations. Each phase writes to .aiwg/, each session reads it. The project carries forward.

> /team — rolling AIWG out across a team? Governance, HITL gates, traceability.

> /extend — build your own agents, skills, addons. Path A/B/C without forking.

> /sandbox — running for hours? Optional VM-grade isolation runtime.

> /h/loop — the alternate hero for this audience.