ai-toolkit

Smart entry point for the Spartan AI Toolkit. Detects project context, routes to the right workflow or command. Use this when you're not sure where to start.

Structured brainstorming — generate ideas, filter fast, rank the top 3

Analyze an existing codebase and generate a structured context map + onboarding spec before making any changes. Use when joining a legacy project or unfamiliar service.

Build a new feature end-to-end — backend, frontend, or full-stack with auto-detection

Activate destructive operation warnings. Claude will detect and require explicit confirmation before running dangerous commands like rm -rf, DROP TABLE, force-push, git reset --hard, overwriting migrations, or deleting production resources.

Create a commit message and PR description by analyzing git diffs

Turn research or ideas into platform-native content — blog posts, tweets, LinkedIn, newsletters

Manage context window — first tries /compact to free space, then saves full handoff if needed. Auto-triggered when Claude detects context pressure, or run manually anytime.

Toggle contributor mode — Claude rates its own skill experience (0-10) after each command and files improvement reports to ~/.spartan/contributor-logs/. Opt-in only.

Generate a daily standup summary based on recent git history and GSD status

Find and fix a bug end-to-end — structured investigation, root cause, test-first fix, and PR

Go deep on a validated idea: market research + competitor teardowns (Stage 3)

Deployment guide and checklist for Railway (primary), AWS, or GCP. Validates readiness, generates config, and walks through the deployment steps.

Set up Playwright end-to-end testing for a Next.js app. Scaffold config, page objects, and critical path tests. Use when the app has enough features to warrant E2E coverage.

Set up and audit environment variables for a service across local, Railway, and AWS environments. Generates .env.example, validates required vars, and flags missing ones.

Define an epic — break big work into ordered features with specs and plans

Thorough PR review for frontend code — loads rules from config, defaults to React/Next.js conventions

Convert a Figma design screen to production code using Figma MCP. Manages token budget (one screen per session), extracts design tokens, and generates typed React components following App Router conventions.

Post-mortem investigation for failed or stuck workflows. Analyzes git history, planning artifacts, and project state to diagnose what went wrong. Use when a phase failed, work got stuck, or you need to understand why something broke.

Lock file edits to a single directory. Claude will refuse to create, modify, or delete files outside the specified directory until /spartan:unfreeze is called. Use when debugging a specific module or making surgical changes.

Create pitch materials + investor outreach drafts (Stage 4)

Dual-agent review — builder presents work, reviewer evaluates, both must accept

Upgrade GSD workflow to v5 — adds decompose step, agent memory layer, and wave-based parallel execution inspired by Service Insight's 6-step agent workflow. Run once to migrate an existing GSD project or set up the new workflow.

Maximum safety — activate both careful mode (destructive operation warnings) and freeze mode (directory lock) simultaneously. Use when working with production configs, database migrations, or any high-risk changes.

Scan current codebase and auto-generate a project-level CLAUDE.md with stack detection, conventions, domain context, and team rules. Use when joining a project or setting up AI workflow for an existing repo.

Set up configurable rules — interactive wizard that generates .spartan/config.yaml

Generate Mom Test interview questions — talk about their life, not your idea

Start a new idea: create project folder, brainstorm, then validate top picks (Stages 1-2)

Scaffold a new Kotlin Micronaut microservice following Spartan conventions and company rules

Fill out a 9-block Lean Canvas one block at a time — end with your riskiest assumptions

Validate your .spartan/config.yaml and rule files — check format, paths, and completeness

Auto-update a single documentation file based on current codebase state. A scoped agent reads the target doc, analyzes the code, and rewrites it to stay current. Use when docs drift from reality.

Deep codebase analysis with parallel agents. Produces 7 structured documents covering stack, architecture, conventions, testing, integrations, and concerns. Use before major refactoring, milestone planning, or team onboarding.

Clean up .memory/ directory — deduplicate entries, remove stale info, fix contradictions, and rebuild the index. Like autoDream but on-demand.

Create a database migration script following company DATABASE_RULES (TEXT not VARCHAR, no FK, soft deletes, UUID PKs)

Scaffold a complete new Next.js application from scratch — App Router, TypeScript, Tailwind, testing setup, API client layer, auth scaffolding, and CI config.

Scaffold a new Next.js feature following App Router conventions — pages, components, server actions, types, and tests.

Understand a new codebase — scan, map architecture, set up rules, and get ready to build

Investigate a monitoring alert end-to-end — metrics, logs, traces, code changes, root cause hypothesis

Create on-call log — pull alerts from monitoring, write structured summary to wiki

Draft personalized investor outreach emails — cold, warm intro, and follow-up

Manage project phases — discuss requirements, plan tasks, execute work, verify results. This is the Spartan wrapper for GSD phase commands. Use after /spartan:project new.

Create investor-facing materials — deck outline, one-pager, memo, or financial model

Write an implementation plan — reads spec, designs architecture, breaks into tasks, runs Gate 2

Full pre-PR workflow — rebase onto main, run all checks (tests, conventions, security), generate PR description, and create the GitHub PR. Run when a feature/fix is complete.

Manage large multi-session projects (> 3 days). Handles full lifecycle — create, check status, start new milestones, complete milestones. This is the Spartan wrapper for GSD project commands.

Run real browser QA on your app using Playwright. Opens Chromium, clicks through flows, finds bugs, and reports issues. Use after building a feature to test it like a real user.

Deep research on any topic — frame the question, gather sources, analyze, and produce a structured report

Perform a thorough PR review using your project's configured rules

Scan your codebase and auto-generate rules from patterns it finds

View and manage active Claude Code sessions. Shows which branches and tasks are running across terminal windows.

Write a feature spec — interactive Q&A, saves to .planning/specs/, runs Gate 1

Full startup pipeline: brainstorm, validate, research, pitch, outreach — pauses at every gate

Manage Claude Code Agent Teams — coordinate multi-agent work with shared tasks, messaging, and parallel execution. Bridges wave-based planning with native agent teams.

Deep competitor analysis — pricing, features, strengths, weaknesses, and where they leave gaps

Set up integration testing infrastructure for a Kotlin Micronaut service using @MicronautTest and Testcontainers

Cost estimation guidance — sizing recommendations, common patterns, optimization tips

Deployment checklist — pre-deploy verification, apply, post-deploy health checks

Detect and categorize infrastructure drift — benign vs concerning changes

Import existing AWS resources into Terraform state with config generation

Create or extend a Terraform module with proper interface, docs, and examples

Guided terraform plan workflow — init, plan, review output, flag destructive changes

PR review for Terraform changes — 8-stage checklist covering structure, security, naming, and state safety

Scaffold service-level Terraform with live/, modules/, envs/ structure and CI/CD

Security audit across IAM, networking, encryption, secrets, access control, and compliance

Guided thinking before coding — 6-phase structured process to prevent building the wrong thing

Remove the directory edit lock set by /spartan:freeze. Claude can edit files anywhere again.

Check for updates and upgrade Spartan AI Toolkit to the latest version. Pulls from GitHub and re-runs the setup script automatically.

UX design workflow — research, define, ideate, design system, prototype, test, handoff, QA

Score a product idea with a quick canvas + 7-area validation checklist — get a GO / TEST MORE / KILL decision

Scan a live web app, extract all features, generate PRD with epics/stories/tasks, export to Notion

Manage parallel workstreams for concurrent milestone work. List, create, switch between, and track progress across independent work tracks. This is the Spartan wrapper for GSD workstream commands.

Write a blog post or article — sounds human, not AI

UI/UX designer that uses external AI (Gemini) for design ideation and asset generation, then produces design docs and prototypes. Reads project design-config.md for brand context.

Design reviewer that catches AI-generic patterns, checks brand compliance, accessibility, and responsive behavior. Works with the designer in a discussion loop for the Design Gate. <example> Context: Designer just created a design doc for a new dashboard screen. user: "Review this design for the Design Gate" assistant: "I'll use the design-critic agent to evaluate the design for AI-generic patterns and brand compliance." </example> <example> Context: /spartan:ux prototype command needs a second opinion on the UI. user: "Run the design critic on this feature" assistant: "I'll spawn the design-critic to review the design doc and give a verdict." </example>

The harshest idea critic. Tries to kill your idea before the market does. Use when you need someone to find every flaw.

Use this agent when you need expert guidance on AWS infrastructure with Terraform, including VPC design, EKS/ECS clusters, RDS databases, ElastiCache, S3, IAM, and OIDC patterns. This agent excels at reviewing Terraform code, designing infrastructure modules, optimizing cloud architecture, and troubleshooting deployment issues. Examples: <example> Context: User needs help designing a service's infrastructure user: "I need to set up RDS and Redis for a new microservice" assistant: "I'll use the infrastructure-expert agent to design the database and cache infrastructure following Spartan conventions." <commentary> Since this involves AWS infrastructure design with Terraform, the infrastructure-expert agent should be used. </commentary> </example> <example> Context: User is debugging a Terraform state issue user: "Terraform plan shows resources being recreated unexpectedly" assistant: "Let me engage the infrastructure-expert agent to diagnose the state drift and recommend a fix." <commentary> State management issues require deep Terraform expertise from the infrastructure-expert agent. </commentary> </example> <example> Context: User needs help with EKS IRSA configuration user: "How should I set up IAM roles for my service pods?" assistant: "I'll use the infrastructure-expert agent to design the IRSA configuration following security best practices." <commentary> IRSA and IAM patterns require the infrastructure-expert agent's security expertise. </commentary> </example>

Use this agent when you need expert guidance on backend development with the Micronaut framework, database design decisions, API architecture, or when bridging backend and frontend concerns. This agent excels at reviewing Micronaut-specific code, optimizing database schemas, designing RESTful APIs, implementing microservices patterns, and providing full-stack architectural recommendations. Examples: <example> Context: User needs help with a Micronaut controller implementation user: "I need to create a new endpoint for user authentication" assistant: "I'll use the micronaut-backend-expert agent to help design and implement this authentication endpoint properly." <commentary> Since this involves Micronaut-specific backend work, the micronaut-backend-expert agent should be used. </commentary> </example> <example> Context: User is working on database optimization user: "Can you review my database schema for the user_profiles table?" assistant: "Let me engage the micronaut-backend-expert agent to analyze your database schema and suggest optimizations." <commentary> Database design review requires the specialized knowledge of the micronaut-backend-expert agent. </commentary> </example> <example> Context: User needs help with Micronaut dependency injection user: "How should I structure my service layer with Micronaut's DI?" assistant: "I'll use the micronaut-backend-expert agent to provide guidance on Micronaut's compile-time dependency injection patterns." <commentary> Micronaut-specific DI patterns require the framework expertise of the micronaut-backend-expert agent. </commentary> </example>

Senior code reviewer for Gate 3.5 — evaluates code design, SOLID principles, clean code, and project rule compliance. Works in discussion with the builder agent. <example> Context: Builder just finished a phase with 5 changed files. user: "Review these changes for Gate 3.5" assistant: "I'll use the phase-reviewer agent to evaluate the code against Gate 3.5 checklist." </example> <example> Context: Build workflow Stage 3 is done, all tasks complete. user: "Run a dual-agent review before shipping" assistant: "I'll spawn the phase-reviewer to do a Gate 3.5 review on all changes." </example>

Plans research projects. Breaks down vague questions into concrete research steps. Use before starting any big research effort.

Use this agent when you need strategic technical guidance, architectural decisions, technology stack recommendations, system design reviews, scalability planning, technical debt assessment, team structure advice, or high-level technical leadership. This agent excels at evaluating trade-offs between different architectural approaches, recommending best practices for distributed systems, microservices, cloud infrastructure, and providing CTO-level insights on technology roadmaps and engineering culture. Examples: <example>Context: User needs help with high-level system design decisions. user: "I need to design a scalable payment processing system that can handle 10k transactions per second" assistant: "I'll use the solution-architect-cto agent to help design this system architecture" <commentary>The user needs architectural guidance for a complex system design, so the solution-architect-cto agent should be used.</commentary></example> <example>Context: User wants advice on technology stack selection. user: "Should we use Kubernetes or serverless for our new microservices platform?" assistant: "Let me consult the solution-architect-cto agent for strategic guidance on this infrastructure decision" <commentary>This is a strategic technical decision requiring CTO-level expertise, perfect for the solution-architect-cto agent.</commentary></example> <example>Context: User needs help with team scaling and technical debt. user: "Our startup is growing from 5 to 50 engineers, how should we restructure our monolith?" assistant: "I'll engage the solution-architect-cto agent to provide guidance on both the technical migration strategy and team organization" <commentary>This requires both architectural expertise and leadership experience, ideal for the solution-architect-cto agent.</commentary></example>

Use this agent when you need strategic infrastructure guidance, multi-account AWS strategy, cost optimization, disaster recovery planning, or environment architecture decisions. This agent excels at evaluating trade-offs between infrastructure approaches, planning migrations, and advising on scaling strategies. Examples: <example> Context: User needs to plan a multi-account AWS strategy user: "We're expanding from one AWS account to separate dev/staging/prod accounts" assistant: "I'll use the sre-architect agent to design the multi-account strategy with proper isolation and cross-account access patterns." <commentary> Multi-account strategy requires the strategic thinking of the sre-architect agent. </commentary> </example> <example> Context: User wants to optimize infrastructure costs user: "Our AWS bill is growing fast, what should we right-size?" assistant: "Let me engage the sre-architect agent to analyze the infrastructure and recommend cost optimizations." <commentary> Cost optimization across the stack requires the broad perspective of the sre-architect agent. </commentary> </example> <example> Context: User is planning a migration from ECS to EKS user: "Should we migrate from ECS to EKS? What's the plan?" assistant: "I'll use the sre-architect agent to evaluate the migration trade-offs and create a phased migration plan." <commentary> Major infrastructure decisions require the sre-architect agent's strategic expertise. </commentary> </example>

Coordinates multi-agent teams for parallel work. Understands GSD planning artifacts, wave decomposition, and Spartan conventions. Use as team lead when creating teams via /spartan:team. <example> Context: User wants to execute a wave plan with multiple work units in parallel. user: "Run wave 1 with agent teams" assistant: "I'll use the team-coordinator to manage the wave execution across multiple agents." </example> <example> Context: User wants a parallel review of a large PR. user: "Get a team to review this PR from different angles" assistant: "I'll spawn a team-coordinator to manage parallel reviewers." </example> <example> Context: User wants parallel research on a topic. user: "Research this from multiple angles at the same time" assistant: "I'll create a research team with the team-coordinator managing the agents." </example>

Creates RPC-style endpoint following layered architecture (Controller → Manager → Repository). Use when creating new API endpoints or CRUD operations.

Write blog posts, guides, tutorials, and long-form content. Sounds like a real person, not AI. Use when the user wants polished written content.

Design RPC-style APIs with layered architecture (Controller → Manager → Repository). Use when creating new API endpoints, designing API contracts, or reviewing API patterns.

Run a structured brainstorm session for startup ideas. Takes a theme or problem and generates ideas with quick gut-checks. Use when the user wants to explore a space or generate new ideas.

Run real browser QA with Playwright. Use when testing a frontend feature, verifying UI before PR, smoke testing after deploy, or investigating reported visual bugs.

CI/CD pipeline patterns for GitHub Actions, PR automation, and deployment workflows. Use when setting up CI, fixing broken pipelines, automating PR checks, or configuring deployment.

Deep competitor analysis. Tear apart a specific competitor or compare multiple competitors. Use when the user names a competitor or asks "who else is doing this?"

Turn one idea into platform-native content for X, LinkedIn, TikTok, YouTube, newsletters. Use when the user wants social posts, threads, scripts, or content calendars.

Database design patterns including schema design, migrations, soft deletes, and Exposed ORM. Use when creating tables, writing migrations, or implementing repositories.

Creates database table with full Kotlin synchronization (SQL migration → Table → Entity → Repository → Tests). Use when adding new database tables or entities.

Run deep research on a topic. Web searches, data collection, source checking, and a structured report. Use when the user needs more than a quick answer.

Design system bootstrapping and token generation. Takes project context and outputs ready-to-use design tokens, Tailwind config, and CSS variables.

Anti-AI-generic design guidelines. Use when creating UI prototypes, reviewing designs for generic AI patterns, or setting up a project design system.

Validate a startup idea with competitor analysis, market signals, and risk assessment. Be brutally honest. Use when the user wants to test if an idea is worth building.

Create pitch decks, one-pagers, memos, financial models, and fundraising materials. Use when the user needs investor-facing docs.

Draft cold emails, warm intro blurbs, follow-ups, and investor communications. Use when the user needs to write to angels, VCs, or accelerators.

Kotlin coding standards including null safety, Either error handling, coroutines, and Exposed ORM patterns. Use when writing Kotlin code, reviewing code quality, or learning project patterns.

Run market research, competitive analysis, investor due diligence, and industry scans. Use when the user wants market sizing, competitor comparisons, fund research, or tech scans.

Investigate a monitoring alert end-to-end. Pulls metrics, logs, traces, and recent code changes to identify root cause. Works with any monitoring MCP.

Create a structured on-call log by pulling alerts from monitoring and writing a summary to your team's wiki. Requires a monitoring MCP (recommended: Datadog) and a wiki MCP (Confluence or Notion).

Creates FastAPI endpoints with layered architecture (Router → Service → Repository). Use when creating new API endpoints, CRUD operations, or scaffolding a new domain module in a FastAPI project.

Python/FastAPI coding standards including async patterns, Pydantic v2, SQLAlchemy 2.0, and project structure. Use when writing Python code, reviewing FastAPI projects, or learning FastAPI conventions.

Testing patterns for FastAPI with pytest-asyncio, httpx AsyncClient, fixtures, and test data factories. Use when writing tests, setting up test infrastructure, or improving coverage in a FastAPI project.

Security best practices for Micronaut/Kotlin backend including authentication, authorization, input validation, and OWASP prevention. Use when implementing auth, validating inputs, or reviewing security.

Structured debugging runbook for backend services. Use when investigating production issues, API errors, performance problems, or when something broke and you need to find why.

Coordinates the full startup idea pipeline from brainstorm to investor outreach. Use when the user starts a new idea project, asks for the 'full pipeline', or references stages/gates.

Quick reference for Terraform conventions including file organization, naming, modules, state, security, and anti-patterns. Use when writing or reviewing Terraform code.

Create or extend reusable Terraform modules with proper structure, interfaces, and documentation. Use when building new infrastructure modules or extending existing ones.

PR review checklist for Terraform changes covering structure, state safety, security, naming, modules, variables, providers, and CI/CD. Use when reviewing Terraform PRs or doing pre-merge checks.

Security audit for Terraform codebases covering IAM, networking, encryption, secrets, access control, and compliance. Use before prod deploys, periodic audits, or new service security review.

Generate complete service-level Terraform infrastructure with modules, environments, and CI/CD. Use when adding Terraform to a new service or bootstrapping infrastructure from scratch.

Testing patterns for Micronaut/Kotlin backend including repository tests, integration tests, and test data builders. Use when writing tests, setting up test infrastructure, or improving coverage.

UI/UX design intelligence with searchable style, palette, typography, and chart databases. Use when designing UI components, choosing colors/fonts, reviewing code for UX issues, building landing pages, or implementing responsive layouts.

Scan a live web app with Playwright, extract all features, generate PRD/epics/stories with priorities and dependencies, export to Notion. Checks required MCP servers before starting.