Inside acs adopt: Deploy 21 Specialized Agents in 15s

Your first day in a new repository is rarely spent writing product code. The acs adopt command was created to eliminate this manual friction. You open a terminal and draft AGENTS.md from scratch. You create .claude/rules/, copy conventions from previous projects, and update relative paths. Then you hand-craft 20 JSON configuration blocks for MCP tooling.

By late afternoon, you have not shipped a single line of production code.

Onboarding an existing team repository is even more frustrating. Every engineer brings personal preferences. One file demands tabs; another demands spaces. Conflicting instructions live side by side in the same workspace directory, leaving your AI agents confused about which standard to enforce.

It is like opening a machine shop without standard operating procedures. You have to interview 21 workers individually, draft separate employment contracts, and write manual guidelines before anyone touches a tool.

Why Manual Agent Setup Consumes Entire Days

The issue is not developer laziness. The root problem is that agent configuration lacks a single source of truth.

Conventions sit in CLAUDE.md. Personas reside in an agents/ directory. Skills live in skills/. Enforcement hooks are defined in settings.json. MCP endpoints are declared in .mcp.json. Five disconnected surfaces, five distinct data formats, and zero tooling to verify mutual consistency.

Compare this with how go mod tidy or cargo build works. You never manage transitive dependency trees by hand. The compiler inspects manifests, resolves the dependency graph, and commits a lockfile. The outcome is deterministic, reproducible, and verifiable.

acs adopt applies this exact engineering rigor to your AI coding agents.

What Actually Happens During the 15-Second Run

This command is not an arbitrary template generator. It executes three disciplined operational phases in sequence.

Phase one, automated stack detection. ACS inspects workspace manifests: go.mod, package.json, pyproject.toml, or Cargo.toml. From these signals, it infers whether the workspace is a Go monorepo, a Node service, or a hybrid architecture. The runtime maps the environment to official presets like go-react or node-solid.

Phase two, deterministic provisioning. Every generated file links to a known, signed origin. Core rulesets, specialist personas, PRD templates, and runtime hooks deploy from a validated upstream bundle. File states and SHA-256 signatures are tracked in .acs/workflow-state.json.

Phase three, three-way conflict classification. Before writing changes, ACS evaluates three inputs: the upstream bundle, previous adoption state, and your current local files. It produces a clear classification: current, requires update, local customization, or actionable conflict.

Existing repositories often contain hard-won local rules. Rather than overwriting them blindly, ACS flags customized files and leaves them untouched.

On-demand skill injection versus prompt stuffing

The legacy approach pastes every project rule into a massive system prompt. Every turn burns thousands of input tokens on rules irrelevant to the immediate task.

ACS enforces lean baselines and injects skills on demand. When you refactor code, AST transformation rules activate. When you modify backend endpoints, strict TDD red-green-refactor instructions load. Token consumption drops, and the agent stays sharply focused.

The Advantage: One Command Provisions the Full Fleet

# Preview changes with zero disk modifications
acs adopt . --dry-run

# Execute full non-interactive adoption
acs adopt . --auto

Within seconds, your workspace receives:

• 21 specialized personas across 5 operational divisions, from software architects to independent verification supervisors.
• 7 autonomous reflexes that keep sessions productive when agents stall or hit context limits.
• RFC 2119 compliant rulesets that eliminate contradictory instructions.
• Project-level .mcp.json definitions that wire all CLI tools to a shared memory database.
• Structured PRD blueprints and phase manifests for complex multi-step tasks.

Several flags streamline onboarding for legacy codebases:

--mode lean installs a lightweight 2KB pointer alongside on-demand rules. --preset overrides auto-detection for unconventional repository layouts. --localize-rules normalizes mixed-language guidelines into standardized English RFC 2119 directives. --mcp-strategy append preserves pre-existing .mcp.json entries without data loss.

Crucially, acs adopt is idempotent. Running it repeatedly produces identical states. When upgrading ACS versions, pristine files update automatically while your customized files remain protected.

acs adopt Blueprint and Architecture Contract

Getting Started

If your repository lacks a CLAUDE.md entirely, run acs adopt . --auto to establish clean baseline guardrails immediately.

If your workspace already has custom rules, run --dry-run first. The resulting summary highlights which files can safely update and which local rules will be protected.

To review complete feature capabilities, visit the ACS features overview. To explore licensing options, inspect the pricing page. Explore the open-source implementation on GitHub ↗.