/initx

InitX - Project Intelligence & Agent Recruitment System

Usage

`/initx [OPTIONS]`

🎯 Core Function

Analyze project codebase, detect technology stack, and **CREATE NEW PROJECT-SPECIFIC AGENTS** tailored to your unique requirements. Saves custom agents to `.claude/agents/` and updates project `CLAUDE.md`.

🚀 Command Modes

🎯 Basic Usage

/initx                    # Smart analysis & agent creation
/initx --preview         # Preview mode (no file creation)
/initx --force          # Force overwrite existing agents

📊 Advanced Options

• `--mode=minimal` - Create only essential agents
• `--focus=security` - Focus on security-specific agents
• `--exclude=ui` - Skip UI/design agents
• `--template=mobile` - Use mobile project template
• `--model=inherit` - Force all agents to use specified model (inherit/sonnet/opus/haiku)

🧠 Intelligence Detection Matrix

Technology Stack Recognition

Frontend: vue (*.vue, nuxt.config.js), react (*.jsx, next.config.js), angular
Backend: fastapi (main.py), spring (pom.xml), go (go.mod), node (express/koa)
Mobile: android (*.kt, AndroidManifest.xml), flutter (pubspec.yaml)
Security: reversing (*.apk, frida scripts), hooking (xposed modules)

Project Complexity Assessment

• **Simple**: 1-2 custom agents (single stack)
• **Medium**: 3-5 custom agents (multi-stack)
• **Complex**: 5-8 custom agents (microservices)
• **Enterprise**: 8+ custom agents (distributed)

🤖 Agent Creation Algorithm

Phase 1: Core Stack Agents

**Creates NEW specialized agents based on detected stack:**

• `vue-{project-name}-developer` - Project-specific Vue expert
• `api-{domain}-specialist` - Custom API integration expert
• `{database}-data-architect` - Database-specific data expert

Phase 2: Domain-Specific Agents

**Creates NEW agents for unique project domains:**

• `{domain}-business-logic-expert` - Business rules specialist
• `{integration}-connector-agent` - Third-party integration expert
• `{platform}-deployment-specialist` - Platform-specific deployment

Phase 3: Quality & Operations Agents

**Creates NEW agents for project-specific QA:**

• `{stack}-testing-specialist` - Stack-specific testing expert
• `{environment}-ops-engineer` - Environment-specific operations

📁 Generated Structure

project_root/
├── .claude/
│   └── agents/                    # NEW custom agents
│       ├── vue-ecommerce-developer.md
│       ├── payment-integration-specialist.md
│       ├── postgres-data-architect.md
│       └── aws-deployment-specialist.md
├── CLAUDE.md                      # Updated with new team
└── .gitignore                     # Updated exclusions

🏗️ Custom Agent Template

⚠️ **LANGUAGE REQUIREMENT**: All agent content MUST be generated in ENGLISH.

---
name: {project-domain}-{specialization}-agent
description: Project-specific {specialization} expert for {project_name}
model: inherit  # Options: inherit | sonnet | opus | haiku
---

You are the **{Project Domain} {Specialization} Agent** for the {project_name} project.

## STRICT AGENT BOUNDARIES

**ALLOWED ACTIONS:**
- {Domain-specific actions based on project analysis}
- {Tech stack specific implementations}
- {Integration and performance optimizations}

**FORBIDDEN ACTIONS:**
- {Cross-domain work} (delegate to {appropriate_agent})
- Infrastructure concerns (delegate to devops-engineer)
- Security audits (delegate to code-review-expert)

**CORE MISSION:** {Single sentence describing the agent's purpose}

## RESPONSIBILITIES

### 1. {Primary Domain Area}
- {Specific responsibilities based on project analysis}
- {Pattern implementations from detected codebase}

### 2. {Quality & Testing}
- {Testing requirements specific to domain}
- {Performance criteria for project}

### 3. {Collaboration}
- Input from: {upstream agents}
- Output to: {downstream agents}
- Coordinate with: {peer agents}

## TECHNOLOGY STACK
**Primary**: {Detected technologies with versions}
**Integrations**: {Third-party services}
**Constraints**: Work exclusively within {project_domain} of {project_name}

🧠 Intelligent Model Selection System

Model Selection Matrix

Complex Reasoning (opus): Architecture design, security analysis, microservices
Balanced Performance (sonnet): Most development agents, API/database, testing
Simple Fast (haiku): Config generation, simple scripts, documentation
Inherit from Parent (inherit): Maintain consistency, avoid switching overhead

Force Model Option (--model parameter)

/initx --model=inherit    # All agents inherit from parent (best for cost control)
/initx --model=sonnet     # All agents use Sonnet (balanced performance)
/initx --model=opus       # All agents use Opus (maximum reasoning) 
/initx --model=haiku      # All agents use Haiku (fastest response)

⚠️ Using `--model` overrides intelligent model selection for consistency/cost control.

User Confirmation Flow

Standard Mode (Intelligent Model Selection)

🤖 Agent Creation - {agent_name}
📊 Recommended: {suggested_model} ({reason})

Select model: [1] ✅ Recommended [2] Opus [3] Sonnet [4] Haiku [5] Inherit
Confirm? [y/N]

Force Model Mode (--model parameter)

🤖 Agent Creation - {agent_name}
📊 Model: {forced_model} (forced by --model)
Confirm? [y/N]

⚠️ IMPORTANT: Language Requirements

**All generated agents MUST be created in English**, regardless of the user's input language:

• Agent names: Always in English (e.g., `vue-ecommerce-developer`, not `vue-电商-开发者`)
• Agent descriptions: Always in English
• Agent content: Always in English
• Documentation comments: Always in English

This ensures consistency and compatibility across all projects and teams.

⚡ Execution Flow

Phase 1: Project Intelligence (15s)