Project Init

When this skill is invoked, it bootstraps a complete multi-agent development environment for the current project — of ANY type.

---

0. Core Principle

This skill works for any domain, not just software. The key insight:

1. Predefined profiles exist for common software types (game, web-app, mobile-app, api-service, cli-tool, library) — these give fast, accurate configuration.
2. Dynamic profile generation handles everything else — the AI interviews the user about their domain, infers the needed roles and workflows, and generates a custom agent team from scratch.

Both paths converge at the same output: a fully configured .claude/ infrastructure with agents, skills, hooks, rules, and coordination docs.

---

1. Detect Existing Configuration

Before doing anything, check if a multi-agent setup already exists:

Glob ".claude/agents/*.md"
Glob ".claude/skills/*/SKILL.md"
Read "CLAUDE.md" (if exists)
Read ".claude/config-meta.json" (if exists)

If .claude/agents/ already contains 3+ agent files: > AskUserQuestion: "This project already has a multi-agent configuration (N agents, M skills). What would you like to do?" > - Options: "[A] Reconfigure — start fresh (existing files backed up)" / "[B] Extend — keep existing, add missing" / "[C] Evolve — switch project phase (e.g. prototype→production)" / "[D] Cancel"

If [C]: run the Evolution Mode flow (see Section 8). If [D]: exit. If [B]: run /expand-team logic instead. If [A]: back up .claude/ to .claude.backup.[timestamp]/.

---

2. Phase 1 — Detection (Read the Project)

Scan the project directory to auto-detect characteristics. Run ALL scans before asking questions.

2a: Project Type Detection (Predefined Profiles)

For each predefined profile, scan for its detect_signals:

Read profiles/game.md
Read profiles/web-app.md
Read profiles/mobile-app.md
Read profiles/api-service.md
Read profiles/cli-tool.md
Read profiles/library.md

For each profile's signals, use Glob to count matches in the project root.

2b: General Project Signals

Also scan for general indicators that help characterize ANY project:

Glob "*.md" (root — README, docs)
Glob "*.py" / "*.ipynb" (data science, scripting)
Glob "*.json" / "*.yaml" / "*.toml" (config-heavy projects)
Glob "*.csv" / "*.xlsx" / "*.parquet" (data projects)
Glob "*.sql" / "migrations/" (database projects)
Glob "Makefile" / "Taskfile*" / "justfile" (build systems)
Glob "LICENSE" / "CHANGELOG*" (open-source library signals)
Glob ".github/" / ".gitlab-ci*" (CI/CD)
Glob "Dockerfile" / "docker-compose*" (containerized)
Glob "data/" / "notebooks/" / "scripts/" (data/analysis projects)
Glob "*.html" / "*.css" (web frontend)
Glob "*.sol" / "hardhat*" / "foundry*" (blockchain)
Glob "*.tex" / "*.bib" (academic/latex)
Glob "backend/" / "frontend/" / "miniprogram/" (multi-tier projects)

2c: Content Analysis

If a README.md exists, read it to understand the project's purpose. If any existing docs exist (docs/, DESIGN.md, etc.), skim them for domain clues.

2d: Present Detection Results

## Project Detection Results

**Best match**: {{type}} ({{confidence}} — {{N}}/M signals matched)
  OR: **No predefined profile matches well** — will generate a custom profile

**Language**: {{lang}}
**Framework**: {{framework or "none detected"}}
**Domain clues**: {{extracted from README/content}}
**Existing config**: {{.claude/ exists?}}

---

3. Phase 2 — Interview (Understand the Domain)

This is where the skill becomes universal. The interview adapts based on whether a predefined profile matched.

3a: If Predefined Profile Matched (High Confidence)

AskUserQuestion with streamlined questions:

Q1: "Detected: {{type}} project. Is this correct?"

• Options: "{{type}} (Recommended)" / "It's something else" / "It's a mix"

Q2: "Team mode?"

• Options: "[A] Solo (Recommended)" / "[B] Small team (2-5)" / "[C] Large team (5+)"

Q3: "Collaboration style?"

• Options:
• "[A] Hierarchical — Director → Lead → Specialist (Recommended for complex projects)"
• "[B] Panel —平等评审, multiple experts review each decision"
• "[C] Pipeline — linear stages, each agent handles one phase"
• "[D] Flat — minimal hierarchy, agents collaborate freely"

Q4: "Review intensity?"

• Options: "[A] Lean (Recommended)" / "[B] Full" / "[C] Solo (no reviews)"

Q5: "Key focus areas?" (multi-select)

• Options vary by profile (e.g., Performance, Security, UX, Testability, Rapid iteration, Documentation)

If Q1 answer is "It's something else": skip to 3b (Dynamic Profile).

3b: If No Profile Matched OR User Says "Something Else" — DYNAMIC PROFILE GENERATION

This is the universal path. The AI interviews the user about their specific domain to build a custom agent team.

Step 1: Understand the Domain

AskUserQuestion (up to 4 questions at once):

Q1 — What is this project? "Describe what this project does in one sentence. For example: 'A stock trading signal system', 'A personal finance tracker', 'A research paper writing pipeline', 'A content creation workflow'."

• Free text input via AskUserQuestion (Other option)

Q2 — What are the main work areas? "What distinct types of work does this project involve? Pick all that apply."

• Options (domain-agnostic list):
• "Data analysis / Processing"
• "Strategy / Decision making"
• "Content creation / Writing"
• "Code / Engineering"
• "Research / Investigation"
• "Design / Creative"
• "Operations / Deployment"
• "Communication / Marketing"
• Multi-select: true

Q3 — Team mode?

• Options: "[A] Solo (Recommended)" / "[B] Small team (2-5)" / "[C] Large team (5+)"

Q4 — What quality checks matter? "What would you want agents to review or validate?"

• Options:
• "Correctness — logic, calculations, data accuracy"
• "Strategy — decisions, risk assessment, alternatives"
• "Quality — code quality, writing quality, design quality"
• "Compliance — rules, regulations, standards"
• "Performance — speed, efficiency, cost"
• Multi-select: true

Step 1b: Collaboration Style

AskUserQuestion: "How should agents work together?"

• Options:
• "[A] Hierarchical — clear chain of command, top-down delegation (Recommended)"
• "[B] Panel —平等评审, experts independently review and score"
• "[C] Pipeline — linear stages, agent per phase"
• "[D] Flat — agents collaborate freely, no strict hierarchy"

Step 2: Deep-Dive on Selected Work Areas

For each selected work area, ask follow-up questions to identify specific roles needed.

If "Data analysis / Processing" selected: AskUserQuestion: "What kind of data work?"

• Options: "Financial/trading data" / "Scientific/research data" / "User/behavioral data" / "Content/media data" / "Operational metrics" / "Other"

If "Strategy / Decision making" selected: AskUserQuestion: "What kind of decisions?"

• Options: "Investment/trading decisions" / "Product/feature decisions" / "Resource allocation" / "Risk management" / "Prioritization" / "Other"

If "Code / Engineering" selected: AskUserQuestion: "What engineering work?"

• Options: "Backend/API" / "Frontend/UI" / "Data pipelines" / "Automation/scripts" / "Infrastructure" / "Other"

If "Content creation / Writing" selected: AskUserQuestion: "What kind of content?"

• Options: "Documentation" / "Marketing/copy" / "Technical writing" / "Creative/narrative" / "Reports/analysis" / "Other"

Step 3: Infer the Agent Team

Based on ALL answers, dynamically compose an agent team. The inference logic adapts to the selected collaboration mode:

For Hierarchical mode (default):

1. One Director agent always — the overall project authority

• Name derived from domain: "trading-director" for trading, "research-lead" for research, etc.
• Model: opus if stakes are high (financial, medical), sonnet otherwise

1. One Lead per selected work area:

• Data analysis → "data-analyst" or "quant-analyst" (if financial)
• Strategy → "strategist" or "risk-analyst" (if financial)
• Code → "tech-lead"
• Content → "content-lead"
• Research → "research-lead"
• Design → "design-lead"
• Operations → "ops-lead"

1. Specialists derived from deep-dive answers:

• Financial data → "market-analyst", "data-engineer"
• Trading decisions → "signal-analyst", "risk-manager"
• Data pipelines → "pipeline-dev", "data-engineer"
• Documentation → "technical-writer"
• Reports → "report-analyst"

1. Quality agents based on Q4 answers:

• Correctness → "validator" or "fact-checker"
• Strategy → "devil's-advocate" (adversarial reviewer)
• Quality → "reviewer" or "critic"
• Compliance → "compliance-auditor"
• Performance → "optimizer"

For Panel mode:

• All agents are平等 tier — no Director/Lead/Specialist hierarchy
• Each agent is an independent expert reviewer
• A "moderator" agent synthesizes opinions and presents consensus
• Each agent gets opus model for equal decision weight

For Pipeline mode:

• Agents are organized as sequential stages: Stage 1 → Stage 2 → ... → Stage N
• Each stage has exactly one responsible agent
• A "pipeline-orchestrator" manages flow and handoffs
• Focus on clear input/output contracts between stages

For Flat mode:

• Minimal structure — typically 2-4 agents maximum
• No formal hierarchy; all agents are peers
• One "coordinator" agent tracks task status
• Agents communicate directly without escalation paths

Step 4: Infer Skills

Based on the work areas, quality needs, and collaboration mode, generate matching skills:

Always generate:

• team-{{domain}} — a pipeline skill for the core feature workflow (see Section 7)
• code-review or equivalent quality check skill

For Analysis work area → analyze skill (structured data analysis workflow) For Strategy work area → strategy-review skill (evaluate decisions with pros/cons/risk) For Code work area → code-review skill For Content work area → content-review skill For Research work area → deep-research skill For Correctness check → validate skill (cross-check facts, data, calculations) For Strategy check → adversarial-review skill (red-team a proposal)

Step 5: Present the Generated Plan

## Custom Agent Team — {{domain}}

Based on your answers, here's the agent team I'll generate:

### Agents ({{N}} total)
| Agent | Tier | Model | Role | Why needed |
|-------|------|-------|------|------------|
{{generated table}}

### Skills ({{M}} total)
| Skill | Description | Agents used |
|-------|-------------|-------------|
{{generated table}}

### Hooks ({{H}} total)
| Hook | Trigger | Purpose |
|------|---------|---------|
{{generated table from Section 7}}

### Workflow
{{How agents collaborate — inferred from the work areas and collaboration mode}}

AskUserQuestion: "Generate this configuration?"

• Options: "[A] Generate all" / "[B] Adjust — let me modify" / "[C] Add more roles" / "[D] Cancel"

---

4. Phase 3 — Generate Files

4a: Create Directory Structure

mkdir -p .claude/agents
mkdir -p .claude/skills
mkdir -p .claude/rules
mkdir -p .claude/docs
mkdir -p .claude/hooks
mkdir -p production/session-state

4b: Generate Agents

For each agent in the plan:

1. Read the appropriate template:

• Director-tier → templates/agent-director.md
• All others → templates/agent-minimal.md

1. Fill the template with domain-specific content:

• {{agent-name}} → the agent's name
• {{Role Title}} → derived from domain (e.g., "Quant Analyst" for trading)
• {{project-description}} → from user's Q1 answer + detection
• {{Responsibilities}} → 5 specific responsibilities for this role in this domain
• {{reports-to}} → from the generated hierarchy

1. Write to .claude/agents/{{name}}.md

CRITICAL for dynamic profiles: Generate REAL, domain-specific responsibilities. For a stock trading project:

• market-analyst: "Analyze price action patterns", "Monitor sector rotation", "Track institutional flow" — NOT generic "Analyze data"
• risk-manager: "Calculate position sizing via Kelly criterion", "Set stop-loss levels based on ATR", "Monitor portfolio correlation" — NOT generic "Manage risk"

Adapt agent template based on collaboration mode:

• Panel mode: Use a modified director template that includes scoring criteria instead of verdict format
• Pipeline mode: Each agent gets explicit input/output contract in its description
• Flat mode: Use minimal template but add peer coordination instructions

4c: Generate Skills

For each skill, read the appropriate template and fill with domain-specific workflow steps:

• Workflow skills → templates/skill-workflow.md
• Review/gate skills → templates/skill-review.md
• Pipeline feature skills → templates/skill-pipeline.md (see Section 7)

Example for a trading project's analyze-market skill:

## 1. Load Data
Read market data files, check data freshness.

## 2. Technical Analysis
Spawn `market-analyst` via Task: analyze trend, momentum, volume signals.

## 3. Fundamental Check
Spawn `fundamental-analyst` via Task: check earnings, valuation, sector health.

## 4. Risk Assessment
Spawn `risk-manager` via Task: calculate position size, set stops, check correlation.

## 5. Synthesize
Present combined analysis with clear buy/hold/sell recommendation.

4d: Generate Pipeline Skill (if collaboration mode = Pipeline or feature-heavy project)

Generate at least one pipeline skill using templates/skill-pipeline.md. This skill orchestrates a complete feature development flow:

Phase 1: Design → domain-expert
Phase 2: Architecture → tech-lead
Phase 3: Implementation → specialists (parallel)
Phase 4: Integration → tech-lead + domain-expert
Phase 5: Validation → qa-engineer
Phase 6: Sign-off → director

Customize the phases and agents based on the project type. Every pipeline skill must have 4-6 phases and clear handoff criteria.

4e: Generate Rules

Generate domain-appropriate rules:

For financial/trading projects:

• No hardcoded values (use config files)
• All strategies must have backtested metrics
• Risk limits must be defined and enforced
• Every trade signal must include confidence level and stop-loss

For data/science projects:

• All data transformations must be reproducible
• Results must include confidence intervals
• Data sources must be cited
• Hypotheses must be stated before analysis

For general software projects:

• Standard coding standards based on detected language

Also generate path-scoped rules if the project has multiple distinct directories (e.g., backend/, frontend/, lib/):

• Create rule files per path scope: rules/backend.md, rules/frontend.md, etc.
• Each rule file applies only to its path scope
• Include a shared rules/common.md for cross-cutting concerns

4f: Generate Hooks

Read templates/hooks-config.md for the hooks generation guide. Generate hooks based on project type and collaboration mode:

Always generate:

1. hooks/session-start.sh — loads project context on session start
2. hooks/validate-commit.sh — pre-commit validation

Conditionally generate:

1. hooks/validate-push.sh — pre-push validation (if CI/CD detected)
2. hooks/detect-gaps.sh — periodic gap detection (if multi-agent team with 5+ agents)
3. hooks/log-agent.sh — agent activity logging (if panel or hierarchical mode)

Write each hook to .claude/hooks/ directory. Each hook must:

• Be a bash script with #!/bin/bash shebang
• Include a comment block explaining what it does
• Exit 0 on success, non-zero on failure
• Include timeout handling (max 30 seconds per hook)

Example hook generation logic:

For web projects: validate-commit checks linting + test pass
For data projects: validate-commit checks data schema validity
For full-stack projects: validate-commit checks API contract sync
For all projects: session-start loads cu

…

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [Quinnx-Tommo](https://github.com/Quinnx-Tommo)
- **Source:** [Quinnx-Tommo/agent-team-skills](https://github.com/Quinnx-Tommo/agent-team-skills)
- **License:** MIT

Install and usage instructions live in the source repository linked above.