MoAI-ADK — Summary

MoAI-ADK (v2.6.0+) is the most technically sophisticated framework in this batch: a single Go binary (moai) that installs a complete "Harness Engineering" environment for Claude Code, including 17+ slash commands routing through a unified natural-language dispatcher, 30 specialized skills, 7 named agents, and 20 lifecycle hook events (the largest hook surface in this batch). Its core thesis is "Harness Engineering" — designing the environment for AI agents rather than writing code directly: engineers write SPECs, configure quality gates, and set up feedback loops; agents do the implementation. MoAI automatically selects TDD (new projects, 10%+ coverage) or DDD (existing projects, <10% coverage) methodology. The /batch skill spawns dozens of parallel agents in isolated git worktrees for large-scale work. The /simplify skill runs automatically after every REFACTOR/IMPROVE phase. A self-evolving "V3R4 harness" lifecycle lets the harness learn and mutate. Compared to seeds, MoAI-ADK is closest to claude-flow in its programmatic scale (38,700+ lines, 38 packages) and hook count, but differs by being a compiled Go binary with near-zero startup time, and by having the most comprehensive hook event surface of any framework analyzed.

MoAI-ADK — Overview

Origin

MoAI-ADK is developed by modu-ai (Korea). Originally Python (~73,000 lines); rewritten in Go for performance. 3 contributors, 1030 stars as of May 2026. Actively developed (pushed May 2026). Available in English, Korean, Japanese, Chinese.

Philosophy

The central thesis is Harness Engineering:

"The purpose of vibe coding is not rapid productivity but code quality." "Human steers, agents execute. The engineer's role shifts from writing code to designing the harness: SPECs, quality gates, and feedback loops."

The framework implements this through:

• Self-Verify Loop: Agents write code → test → fail → fix → pass cycle autonomously
• Context Map: Codebase architecture maps always available
• Session Persistence: progress.md tracks completed phases; interrupted runs resume
• Failing Checklist: Acceptance criteria registered as pending tasks at run start
• Garbage Collection: Periodic removal of dead code and AI slop
• Scaffolding First: Empty file stubs before implementation to prevent entropy

Automatic Methodology Selection

New project or 10%+ coverage → TDD (RED → GREEN → REFACTOR)
Existing project < 10% coverage → DDD (ANALYZE → PRESERVE → IMPROVE)

Auto-detected at moai init, overridable via --mode <tdd|ddd>.

Key Numbers

• 38,700+ lines of Go code
• 38 packages
• 85-100% test coverage
• 26 specialized AI agents + 47 skills
• 18 programming languages supported
• 27 Claude Code hook events (actual registered: 20 distinct events seen in settings.json)

Go Rewrite Rationale

MoAI-ADK — Architecture

Distribution

• Type: Single Go binary (prebuilt for macOS, Linux, Windows/WSL)
• Install: curl -fsSL https://raw.githubusercontent.com/modu-ai/moai-adk/main/install.sh | bash
• Language: Go 1.26+
• Version analyzed: latest main (May 2026)

Installation

# macOS / Linux / WSL
curl -fsSL https://raw.githubusercontent.com/modu-ai/moai-adk/main/install.sh | bash

# Windows (PowerShell 7.x+)
irm https://raw.githubusercontent.com/modu-ai/moai-adk/main/install.ps1 | iex

# Build from source
git clone https://github.com/modu-ai/moai-adk.git
cd moai-adk && make build

Directory Tree (post-init)

project/
├── .claude/
│   ├── settings.json            # 20 hook events configured
│   ├── agents/
│   │   └── moai/                # 7 agent definitions
│   │       ├── builder-harness.md
│   │       ├── evaluator-active.md
│   │       ├── manager-develop.md
│   │       ├── manager-docs.md
│   │       ├── manager-git.md
│   │       ├── manager-spec.md
│   │       └── plan-auditor.md
│   ├── commands/
│   │   └── moai/                # 17 slash commands
│   ├── hooks/
│   │   └── moai/                # 33 hook handler shell scripts
│   ├── rules/
│   │   └── moai/                # Core rules (constitution, workflow, protocols)
│   └── skills/
│       └── moai/                # Skills organized by type
│           ├── SKILL.md         # Unified orchestrator (main entry)
│           ├── team/            # 6 team agent files
│           └── workflows/       # 20 workflow files
├── .moai/
│   ├── config/
│   │   └── sections/
│   │       └── quality.yaml     # development_mode (tdd|ddd)
│   └── project/
│       └── codemaps/
├── CLAUDE.md                    # Project identity + agent catalog
└── CLAUDE.local.md              # Local overrides

Required Runtime

• Git (required)
• Go binary (zero external dependencies)
• macOS, Linux, or Windows/WSL

Target AI Tools

Claude Code exclusively. The binary installs into .claude/ directory structure.

Go Package Structure (38 packages)

cmd/           # CLI entry points
internal/      # Core implementation
pkg/           # Shared packages

MoAI-ADK — Components

Commands (17 slash commands, all route through unified moai skill)

Plus: release-update, harness (V3R4 self-evolving lifecycle).

Skills (30 skill files in .claude/skills/moai/)

Organized by domain:

• moai-foundation-core — core principles
• moai-foundation-quality — quality gates
• moai-foundation-thinking — reasoning patterns
• moai-foundation-cc — Claude Code specifics
• moai-workflow-tdd — TDD workflow
• moai-workflow-ddd — DDD workflow
• moai-workflow-spec — SPEC management
• moai-workflow-loop — iterative fix loop
• moai-workflow-design — design workflow
• moai-workflow-project — project docs
• moai-workflow-ci-loop — CI integration
• moai-workflow-gan-loop — GAN-style evaluation loop
• moai-workflow-testing — test strategy
• moai-workflow-worktree — git worktree management
• moai-design-system — design system patterns
• moai-domain-* (7 domain skills) — backend, frontend, database, brand design, copywriting, ideation, research, design handoff
• moai-ref-* (5 reference skills) — API patterns, git workflow, OWASP checklist, React patterns, testing pyramid
• moai-harness-learner — V3R4 harness learning
• moai-meta-harness — Meta-harness orchestration

Agents (7 in .claude/agents/moai/)

Team Agents (6 in .claude/skills/moai/team/)

Hooks (20 events, 33 handler scripts)

All events registered in .claude/settings.json:

Plus: status-transition-ownership.sh, sync-phase-quality-gate.sh, team-ac-verify.sh

MCP Server

.mcp.json present in repo — MCP server integration configured.

State Files

• .moai/config/sections/quality.yaml — development mode
• .moai/project/codemaps/ — architecture documentation
• progress.md — session progress tracking

MoAI-ADK — Uniqueness & Positioning

differs_from_seeds

MoAI-ADK is closest to claude-flow in its programmatic scale (both have large codebases, extensive hook coverage, and multi-agent orchestration), but differs fundamentally in implementation: claude-flow is JavaScript/SQLite/MCP, MoAI-ADK is Go/file-based/compiled binary. The hook event surface (20 events, 33 handlers) exceeds all seeds — spec-kit has 18 hooks (2 per command), but MoAI registers TeammateIdle, TaskCompleted, TaskCreated, InstructionsLoaded, CwdChanged, FileChanged, PermissionDenied events that no seed framework uses. The automatic TDD/DDD methodology selection based on code coverage is unique across all seeds and this batch. The MX tag protocol (in-code annotations as persistent agent context) and the self-evolving V3R4 harness lifecycle are also unique. Most similar to superpowers in enforcing quality gates automatically, but MoAI goes further with 20 hooks vs. superpowers' 1.

Positioning

MoAI-ADK targets teams who want the highest possible automation density in their Claude Code environment. It is the most complete "batteries included" harness: 17 commands, 30 skills, 7 named agents, 6 team agents, 20 hook events, auto-methodology selection, auto-simplify, auto-PR, self-evolving harness. The Go binary makes it startup-fast and dependency-free.

Distinctive Opinions

1. "Harness Engineering" — the engineer's job is designing the environment, not writing code.
2. Auto-methodology selection — TDD vs. DDD should be determined by current coverage, not human choice.
3. /simplify auto-runs after every REFACTOR/IMPROVE — quality review is not optional.
4. MX tags — context should live in code alongside the code, not only in external documents.
5. Self-evolving harness — the framework should learn from usage and update its own behavior.

Observable Failure Modes

1. Claude Code only: No multi-runtime support despite Go binary.
2. Complexity: 20 hooks, 33 handler scripts, 30 skills — the most complex deployment in this batch. High cognitive overhead.
3. Korea-origin bias: Primary documentation and community in Korean; English docs are translations and may lag.
4. V3R4 harness stability: Self-evolving system means the harness can change behavior unpredictably without rollback discipline.

Explicit Antipatterns

Not documented in the README, but the framework's constitution (.claude/rules/moai/core/moai-constitution.md) likely contains them — unavailable in the public repo tree.

Cross-References

Cites /simplify and /batch as Claude Code native skills that MoAI invokes — suggesting tight coupling with the broader Claude Code ecosystem.