Spartan AI Toolkit — Summary

Spartan AI Toolkit is an npm-installable Claude Code plugin delivering a comprehensive engineering discipline layer: 73 slash commands (70 under spartan:* + meta), 34 skills, 9 specialized reviewer agents, 28 coding rules across 8 stack profiles, 5 quality gates, and a 3-layer agent memory system. The framework enforces end-to-end workflows — each workflow leader command (build, debug, startup, onboard, research) runs a full pipeline (spec → design → TDD → code review → PR) with mandatory quality gates between every step and git worktrees per feature. It mandates worktree isolation (MANDATORY in the build command), spawns dedicated reviewer agents rather than allowing self-review, and requires conventional commits. A PostToolUse statusline hook and a SessionStart update-check hook are the only Claude Code lifecycle hooks shipped. Compared to seeds: Spartan is architecturally similar to openspec (mirrored commands + quality gates) but substantially richer — 73 commands vs openspec's 11, enforced worktree isolation, stack-specific profiles, and a reviewer-agent separation that is unique among seeds and batch members.

Spartan AI Toolkit — Overview

Origin

Repo: c0x12c/ai-toolkit (GitHub org: c0x12c). Display name: "Spartan AI Toolkit". npm: @c0x12c/ai-toolkit v1.26.0. JavaScript, no license specified in package.json. 72 stars. 7 contributors. Author: Khoa Tran (c0x12c). Created March 2026.

Philosophy

From README:

"Stop AI coding agents from shipping sloppy code."

"AI coding agents are fast. They're also careless. They skip tests, ignore your coding standards, push without review, and forget everything between sessions."

"Spartan fixes that. One command runs a full engineering workflow — spec, plan, TDD, code review, PR — with quality gates between each step. Your rules, your standards, enforced every time."

Key beliefs:

1. Workflow leaders not just prompts — commands run pipelines, not one-off actions
2. Quality gates before progression — nothing advances without passing the gate
3. No self-review — always spawn a dedicated reviewer agent (never "let Claude check its own work")
4. Worktree isolation — every feature in its own worktree (MANDATORY in build command)
5. Stack-specific rules — coding rules should match your actual tech stack

From README: Before/After

"Without Spartan: 'Build this feature' → jumps straight to code, no plan, no tests, pushes broken code" "With Spartan: /spartan:build → writes spec, plans tasks, TDD for each, code review, then PR"

Plugin Description

From plugin.json:

"Engineering discipline layer for Claude Code — 5 workflows, 69 commands, 21 rules, 29 skills, 9 agents organized in 12 packs"

Spartan AI Toolkit — Architecture

Distribution

• npm: npx @c0x12c/ai-toolkit@latest --local (interactive menu)
• Claude Code plugin: toolkit/.claude-plugin/
• Installer installs commands into .claude/commands/spartan/

Install Methods

npx @c0x12c/ai-toolkit@latest --local          # Interactive menu
npx @c0x12c/ai-toolkit@latest --local --packs=backend-micronaut,frontend-react
npx @c0x12c/ai-toolkit@latest --local --packs=all

Directory Structure (repo)

c0x12c/ai-toolkit/
  toolkit/
    .claude-plugin/
      plugin.json          # Claude Code plugin manifest
      marketplace.json
    commands/
      spartan.md           # Router command
      spartan/             # 70 individual spartan:* commands
    skills/                # 34 skills (domain knowledge packs)
    agents/                # 9 specialized reviewer/planner agents
    hooks/
      spartan-statusline.js     # PostToolUse hook
      spartan-check-update.js   # SessionStart hook
    rules/                 # Stack-specific coding rules
    profiles/              # 8 stack profiles
    packs/                 # Pack bundles
    frameworks/            # Per-framework utilities
    lib/                   # Shared library
    templates/             # Project templates
    scripts/               # Build scripts
    claude-md/             # CLAUDE.md templates
    codex/                 # Codex compatibility
    bin/                   # CLI binary
    bridges/               # External integrations
    experiments/           # Experimental features
  .claude/                 # Example Claude config
  .claude-plugin/          # Root-level plugin
  .codex/                  # Codex config

Required Runtime

• Node.js (npm/npx install)
• Claude Code (primary target)
• Codex (secondary support)

Target AI Tools

Claude Code (primary), Codex (secondary), Cursor, Windsurf, Copilot (via rules being plain markdown).

Spartan AI Toolkit — Components

Commands (73 total)

5 Workflow Leaders

Key Individual Commands (70 under spartan:*)

Including: brainstorm, brownfield, build, careful, codex, commit-message, commit-message-with-codex, content, context-save, contribute, daily, debug, deep-dive, deploy, e2e, env-setup, epic, fe-review, figma-to-code, freeze, fundraise, gate-review, guard, init-project, init-rules, interview, js-security, kickoff, kotlin-service, lean-canvas, lint-rules, magic-doc, memory-consolidate, migration, next-app, next-feature, onboard, ops-investigate-alert, ops-oncall-log, outreach, pitch, plan, pr-ready, qa, research, review, scan-rules, sessions, ship-pr, ship-pr-codex, spec, startup, teardown, testcontainer, tf-cost, tf-deploy, tf-drift, tf-import, tf-module, tf-plan, tf-review, tf-scaffold, tf-security, think, unfreeze, update, ux, validate, web-to-prd, write, and more.

Meta Command

/spartan — smart router that figures out what the user needs.

Skills (34 domain knowledge packs)

Examples: api-endpoint-creator, backend-api-design, brainstorm, browser-qa, ci-cd-patterns, competitive-teardown, database-patterns, deep-research, design-intelligence, idea-validation, investor-materials, js-security-audit, kotlin-best-practices, market-research, python-api-endpoint-creator, python-best-practices, python-testing-strategies, security-checklist, service-debugging, startup-pipeline, terraform-best-practices, terraform-module-creator, terraform-review, terraform-security-audit, terraform-service-scaffold, testing-strategies, ui-ux-pro-max, web-to-prd.

Agents (9)

Hooks (2)

Coding Rules (28+)

Stack-specific rules in rules/ — organized by language/framework.

Stack Profiles (8)

kotlin-micronaut, react-nextjs, go-standard, python-django, python-fastapi, java-spring, typescript-node, custom.

Quality Gates (5)

Built into the workflow leaders: Gate 1 (post-spec), Design Gate, Gate 2 (post-plan), Gate 3 (post-TDD), Gate 3.5 (post-code-review), Gate 4 (pre-PR).

Spartan AI Toolkit — Uniqueness & Positioning

Differs from Seeds

Spartan is most architecturally similar to openspec (mirrored command structure, quality-gate enforcement, spec-first workflow) but with dramatically larger scope: 73 commands vs openspec's 11, git worktree isolation (MANDATORY) vs openspec's none, 9 reviewer agents vs openspec's 0, 8 stack-specific profiles vs openspec's single approach. The mandatory reviewer-agent separation (never self-review) is a distinctive opinion not present in any seed. The 3-layer memory system (index → topics → transcript archive) resembles taskmaster-ai's file-based state but is explicitly structured for cross-session continuity rather than task tracking. The spec-kit seed is the closest comparator for the hook + command + quality-gate pattern, but spec-kit has 18 hooks vs Spartan's 2, and Spartan has far more domain commands. BMAD-METHOD is closest for the agent specialization (6 personas), but Spartan's 9 agents are narrower-scoped reviewers rather than full personas.

Positioning

Signal type: workflow-enforcing quality gates + mandatory reviewer spawning Intervention point: phase gate (prompts enforce each step before proceeding) + PostToolUse statusline Unique features: 73 commands, 8 stack profiles, mandatory git worktree per feature, mandatory reviewer-agent (never self-review), 3-layer memory, 5 named quality gates Target user: professional dev teams who want systematic engineering discipline applied to AI-generated code

Observable Failure Modes

• Mandatory reviewer spawning costs additional context/tokens per session
• 73 commands means high cognitive load (the /spartan router mitigates this)
• Worktree isolation requires clean git repo state
• Stack profiles must be configured per project (init-rules command)
• Plugin.json says "69 commands" but repo has 70+ — minor inconsistency
• No license in package.json is a concern for enterprise adoption
• 72 stars — decent traction but not mainstream

Relationship to Batch 31

Spartan is the only framework in Batch 31 that is primarily a workflow-discipline layer rather than a safety/guardrail layer. Where clauder, Sponsio, DashClaw, and pi-steering-hooks prevent bad things from happening at runtime, Spartan enforces good engineering practices from the start of each feature. The closest peers in this batch are vibelint (audit) and ctxlint (pre-session lint) but Spartan's intervention is active workflow enforcement, not passive analysis.