Engineering Team Initialization

Collect project information through interactive Q&A and create an Agent engineering team led by a Lead role.

Supported Team Types

#	Type	Lead Role	Directory	Applicable Scenarios
1	Software Development	PM	dev	New project development, feature iteration
2	Software Testing	Test Manager	testing	System testing, quality assurance
3	Reverse Engineering	Reverse Engineering Lead	reverse	Binary analysis, protocol reverse-engineering, malware analysis
4	Debugging/Bug Fixing	Debug Lead	debug	Troubleshooting, performance issue localization
5	Security Research	Security Lead	security	Vulnerability discovery, security assessment (requires legal authorization)
6	CTF Competition	Captain	ctf	CTF contests, security challenges
7	Operation & Maintenance	O&M Manager	ops	Deployment & O&M, infrastructure management
8	Discussion/Seminar	Moderator	discuss	Solution design, technology selection, requirement discussion, brainstorming

Detailed role lists for each type can be found in

references/role-catalog.md

Interactive Q&A Process

Use the AskUserQuestion tool to ask users in sequence.

Question 0: Team Type

AskUserQuestion:
  question: "Please select the type of team to create"
  header: "Team Type"
  options:
    - label: "Software Development"
      description: "New project development, feature iteration"
    - label: "Software Testing"
      description: "System testing, quality assurance"
    - label: "Reverse Engineering"
      description: "Binary analysis, protocol reverse-engineering"
    - label: "Debugging/Bug Fixing"
      description: "Troubleshooting, performance localization"
    - label: "Security Research"
      description: "Vulnerability discovery, security assessment (requires legal authorization)"
    - label: "CTF Competition"
      description: "CTF contests, security challenges"
    - label: "Operation & Maintenance"
      description: "Deployment & O&M, infrastructure management"
    - label: "Discussion/Seminar"
      description: "Solution design, technology selection, requirement discussion, brainstorming"
  multiSelect: false

Record the user-selected

team_type

and map it to the corresponding directory name:

Software Development → dev
Software Testing → testing
Reverse Engineering → reverse
Debugging/Bug Fixing → debug
Security Research → security
CTF Competition → ctf
Operation & Maintenance → ops
Discussion/Seminar → discuss

Question 1: Project Name

$ARGUMENTS

is not empty, use it as the project name and skip this question.

AskUserQuestion:
  question: "Please enter the project name (in English, used as team name, e.g., my-webapp)"
  header: "Project Name"
  options:
    - label: "my-project"
      description: "Use default name"
    - label: "Enter custom name"
      description: "Input in 'Other'"
  multiSelect: false

Question 2: Project Description

AskUserQuestion:
  question: "{Adjust wording based on team_type}"
  header: "Project Description"
  options: {Provide 2-4 typical scenario options based on team_type}
  multiSelect: false

Wording mapping:

dev: "Please briefly describe the project goals and scope"
testing: "Please describe the system under test and testing goals"
reverse: "Please describe the reverse-engineering target and analysis purpose"
debug: "Please describe the issue to be debugged and its symptoms"
security: "Please describe the goals and scope of the security research"
ctf: "Please describe the competition name and format"
ops: "Please describe the O&M goals and infrastructure overview"
discuss: "Please describe the discussion topic and expected outcomes"

Question 3: Tech Stack/Target Platform

AskUserQuestion:
  question: "{Adjust wording based on team_type}"
  header: "Tech Stack"
  options: {Provide 2-4 typical options based on team_type}
  multiSelect: true

Wording mapping:

dev: "What tech stack does the project use?"
testing: "What is the tech stack of the system under test?"
reverse: "Target platform and architecture? (x86/ARM/MIPS, Windows/Linux/Android)"
debug: "Tech stack and environment where the issue occurs?"
security: "Tech stack and platform of the research target?"
ctf: "Competition preference direction and tools?"
ops: "Infrastructure tech stack? (Linux/K8s/AWS/Docker)"
discuss: "Which fields does the discussion involve? (Used to configure professional backgrounds of expert roles)"

Question 4: Role Selection

Display the role list for the current team_type. The Lead role is automatically included and does not need to be selected.

AskUserQuestion:
  question: "Select required roles ({lead_role} is included by default). For multi-instance roles, specify the quantity in 'Other' using the format 'developer x2'"
  header: "Team Roles"
  multiSelect: true
  options:
    - label: "All Roles (Recommended)"
      description: "Include one of each role in this type"
    - label: "Core Team"
      description: "{Core role subset for this type}"
    - label: "Minimum Team"
      description: "{lead + 1-2 core roles}"
    - label: "Custom"
      description: "Specify roles and quantities in 'Other'"
  multiSelect: false

Core Team mapping:

dev: pm + architect + developer + tester
testing: test-manager + test-architect + functional-tester + automation-tester
reverse: re-lead + static-analyst + dynamic-analyst
debug: debug-lead + root-cause-analyst + fix-engineer
security: security-lead + vuln-hunter + security-auditor
ctf: captain + web + pwn + reverse
ops: ops-manager + sys-engineer + monitor-engineer
discuss: moderator + domain-expert + critic + synthesizer

Minimum Team mapping:

dev: pm + developer
testing: test-manager + functional-tester
reverse: re-lead + static-analyst
debug: debug-lead + fix-engineer
security: security-lead + vuln-hunter
ctf: captain + web
ops: ops-manager + sys-engineer
discuss: moderator + domain-expert

Question 4.5: Discussion Rounds (Triggered only for discuss type)

AskUserQuestion:
  question: "Maximum number of discussion rounds per topic?"
  header: "Discussion Rounds"
  options:
    - label: "3 rounds (Default)"
    - label: "5 rounds"
    - label: "Custom"
  multiSelect: false

max_rounds

will be written into the configuration and

<project_context>

of the prompt.

Question 5: Working Directory

AskUserQuestion:
  question: "Where is the project working directory?"
  header: "Working Directory"
  options:
    - label: "Current Directory"
      description: "Use current working directory"
    - label: "Specify Path"
      description: "Input absolute path in 'Other'"
  multiSelect: false

Confirmation Step

Output the summary information, then confirm:

Team Configuration Summary
--------------------
Team Type: {team_type_name}
Project Name: {project_name}
Project Description: {description}
Tech Stack:   {tech_stack}
Working Directory: {work_dir}

Team Members:
  - {lead_role} x1 (Lead)
  - {role_name} x{count}
  ...

Estimated {N} Agents to be created
--------------------

AskUserQuestion:
  question: "Confirm the above configuration and create the team?"
  header: "Confirmation"
  options:
    - label: "Confirm Creation"
      description: "Start creating the team"
    - label: "Modify Configuration"
      description: "Restart the Q&A process"
    - label: "Cancel"
      description: "Abandon creation"
  multiSelect: false

Team Creation Process

After user confirmation, execute the following steps.

Step 1: Create Team

TeamCreate:
  team_name: "{project_name}"
  description: "{team_type_name} - {description}"

Step 2: Read Role Definitions and Workflows

Role definition path:

~/.claude/skills/team-init/references/{type_dir}/roles/{role_code}.md

Workflow path:

~/.claude/skills/team-init/references/{type_dir}/workflow.md

Note: The above paths are based on the actual installation directory of the skill. Confirm the actual path of the skill when using the Read tool.

Use the Read tool to read the role definition file for each selected role. Also read the workflow.md for this type.

Step 3: Build Role Prompt

Combine the prompt for each member:

You are the {role_name} of the "{project_name}" project.

<project_context>
Project Name: {project_name}
Team Type: {team_type_name}
Project Description: {description}
Tech Stack: {tech_stack}
Working Directory: {work_dir}
</project_context>

<team_members>
{List all members' names and roles}
</team_members>

<workflow>
{Content of workflow.md}
</workflow>

<your_role>
{Full content of the corresponding role .md file}
</your_role>

Step 4: Create Initial Tasks

Use TaskCreate to create a task skeleton based on the phases in workflow.md. Set blockedBy dependencies between phases. Assign the first task to the Lead role.

Step 5: Derive Team Members

The Lead role must be created first.

Agent:
  name: "{member_name}"
  subagent_type: "general-purpose"
  team_name: "{project_name}"
  prompt: "{Prompt built in Step 3}"
  mode: "bypassPermissions"
  description: "Team member: {role_name}"

Naming rules:

Single-instance roles: Use the code directly (pm, architect, captain, etc.)
Multi-instance roles: code-sequence number (developer-1, web-2, etc.)

Creation order: Create Lead first, then create other roles in parallel.

Step 6: Save Team Configuration to Project Directory

Save the team configuration to

.team-profiles/{project_name}.yaml

in the project working directory for reuse via

/team-load

later.

Use the Write tool to create the file:

yaml

# Team Configuration - Automatically generated by /team-init
# Use /team-load {project_name} to directly load this configuration to create a team

format: template
team_type: "{type_dir}"           # dev/testing/reverse/debug/security/ctf/ops/discuss
team_type_name: "{team_type_name}" # English name
description: "{description}"
tech_stack: "{tech_stack}"
work_dir: "{work_dir}"

roles:
  # Lead role (automatically included)
  - role: "{lead_role_code}"
    count: 1
    is_lead: true
  # Other roles
  - role: "{role_code}"
    count: {N}
  # ... List all selected roles and their quantities

After saving, output the prompt:

Team configuration saved to: {work_dir}/.team-profiles/{project_name}.yaml
You can directly load this team configuration using /team-load {project_name} later.

Step 7: Notify Lead to Start

SendMessage:
  type: "message"
  recipient: "{lead_name}"
  content: |
    Team creation completed.
    - Project: {project_name}
    - Description: {description}
    - Tech Stack: {tech_stack}
    - Working Directory: {work_dir}
    - Team Members: {member_list}

    Please start the first phase of work.
    Team Configuration: ~/.claude/teams/{project_name}/config.json
    Workflow: ~/.claude/skills/team-init/references/{type_dir}/workflow.md
    Role Definitions: ~/.claude/skills/team-init/references/{type_dir}/roles/
  summary: "Team created, start project"

Reference Resources

references/role-catalog.md
- Complete role lists for each team type
references/{type_dir}/roles/{role}.md
- Detailed definitions for each role
references/{type_dir}/workflow.md
- Workflow definitions for each team type

team-init

NPX Install

Tags

SKILL.md Content (Chinese)