Description

Multi-agent development team workflow skill. Use when coordinating complex development tasks requiring multiple specialized roles - PM, Architect, Developer,...

README (SKILL.md)

Class Seven - Multi-Agent Development Team

Name: Class Seven
Author: russellfei

Class Seven (七班) is a structured multi-agent workflow that treats sub-agents as specialized development team members.

When to Use

Use this skill when:

Complex development tasks requiring multiple perspectives/roles
Tasks needing PM planning + architecture + implementation + testing
Debugging scenarios requiring systematic investigation
Code review and quality assurance workflows
Projects requiring end-to-end delivery (plan → build → test → deploy)

Team Structure

Main Session (Manager)
├── PM Agent (产品经理)
├── Architect Agent (架构师)
├── Developer Agent (开发工程师)
├── Tester Agent (测试工程师)
└── Debugger Agent (调试专家)

Workflow Phases

Phase 1: Task Analysis & Planning

Manager (Main Session) analyzes task complexity
Spawn PM Agent for requirement clarification
PM returns: requirements doc, scope, acceptance criteria

Phase 2: Architecture & Design

Spawn Architect Agent with PM output
Architect returns: tech stack, module design, interfaces

Phase 3: Implementation

Spawn Developer Agent with architecture specs
Developer returns: implemented code

Phase 4: Quality Assurance

Spawn Tester Agent with code + requirements
Tester returns: test plan, test cases, bugs found

Phase 5: Debugging (if needed)

Spawn Debugger Agent with bug reports
Debugger returns: root cause analysis, fixes

Phase 6: Integration & Delivery

Manager reviews all outputs
Integrates final deliverable
Validates against acceptance criteria

Tool Selection Matrix

Task Type	Primary Tool	Secondary Tool	Reason
Complex architecture	Claude Code	Kimi	Deep reasoning, context management
Quick prototyping	Kimi	Native	Fast iteration, lower latency
Deep debugging	Claude Code	Kimi	Multi-file analysis, bug tracing
Code review	Kimi	Claude Code	Pattern recognition, best practices
Testing	Native	Kimi	Deterministic execution
Documentation	Kimi	Native	Chinese/English bilingual

Agent Personas

PM Agent

Role: 产品经理
Expertise: Requirements analysis, user stories, acceptance criteria
Output: PRD, user stories, scope definition
Tools: Kimi (for Chinese context), Claude Code (for complex products)

Architect Agent

Role: 架构师
Expertise: System design, tech stack selection, API design
Output: Architecture doc, module diagrams, interface specs
Tools: Claude Code (preferred for architecture), Kimi (for validation)

Developer Agent

Role: 开发工程师
Expertise: Code implementation, refactoring, optimization
Output: Production-ready code
Tools: Claude Code (complex logic), Kimi (quick implementation), Native (boilerplate)

Tester Agent

Role: 测试工程师
Expertise: Test design, edge case identification, quality assurance
Output: Test cases, test scripts, bug reports
Tools: Native (execution), Kimi (test design), Claude Code (complex scenarios)

Debugger Agent

Role: 调试专家
Expertise: Root cause analysis, performance profiling, bug fixing
Output: RCA report, patches, prevention recommendations
Tools: Claude Code (deep analysis), Kimi (pattern matching)

Execution Modes

Mode A: Full Team (Full Orchestration)

All 5 phases executed sequentially. Use for complex projects.

Mode B: Sprint Team (Dev + Test)

Skip PM/Architect phases. Use when requirements are clear.

Mode C: Firefighter (Debug Only)

Debugger agent only. Use for urgent bug fixes.

Mode D: Review Board (PM + Tester)

Code review workflow. Use for quality gates.

Quick Commands

# Full team deployment
class_seven deploy --mode=full --task="\x3Cdescription>"

# Sprint mode
class_seven deploy --mode=sprint --specs="\x3Crequirements>"

# Debug mode
class_seven deploy --mode=debug --bug="\x3Cbug description>"

Best Practices

Always start with task analysis - Determine mode and required agents
Pass context explicitly - Each agent receives relevant previous outputs
Set clear boundaries - Define what each agent should/shouldn't do
Use appropriate timeout - Complex tasks need longer timeouts
Review before integration - Manager validates all outputs

Error Handling

If an agent fails or produces insufficient output:

Analyze failure reason
Respawn with clearer instructions or different tool
Consider breaking task into smaller sub-tasks
Escalate to human if stuck after 2 retries

References

Detailed workflow patterns: See references/workflows.md
Tool integration guide: See references/tools-guide.md
Example projects: See references/examples.md

Usage Guidance

This skill appears to implement a reasonable multi-agent dev workflow, but review the following before installing or following its instructions: - Do not run remote installer scripts piped directly into a shell (irm | iex or curl | sh). That executes code fetched from the network with no local review — replace with official package installers, verified releases, or manual review of the script first. - Verify the installer domains (e.g., claude.ai is Anthropic's domain; confirm code.kimi.com is the legitimate vendor). If you can't confirm, avoid installing that CLI. - The skill assumes the agent can read code, logs, and local project directories. Confirm what access your agent runtime grants and limit it to only the repositories/paths needed. - The SKILL.md references helper functions (sessions_spawn, fetch_pr, identify_modules). Confirm these are safe built-ins in your agent environment and understand their permissions and network behavior. - Because the skill doesn't declare any credentials but suggests tools that likely require API keys/tokens, prepare to provide credentials separately and audit where those tokens are stored/used. - If you plan to allow autonomous invocation, consider restricting it while you test the skill in a sandboxed environment and verify the toolchain and installer sources. If you want a safer assessment, provide: (1) confirmation/verified URLs for any recommended installers, (2) documentation for sessions_spawn/fetch_pr runtime APIs, and (3) whether this agent will have direct filesystem or network access in your deployment — that information would raise confidence to high or allow targeted remediation steps.

Capability Analysis

Type: OpenClaw Skill Name: class-seven Version: 1.0.0 The skill is classified as suspicious primarily due to the presence of `irm https://... | iex` (Invoke-RestMethod | Invoke-Expression) commands in `references/tools-guide.md`. These instructions, intended for tool installation, represent a significant Remote Code Execution (RCE) vulnerability as they download and execute arbitrary PowerShell scripts from external URLs without prior review. While the target domains (claude.ai, kimi.com) are legitimate, this method of installation is a critical supply chain risk. Additionally, the explicit configuration of agents to "Use Windows PowerShell commands" with prompt-based filtering for dangerous commands (e.g., `rm -rf`) in the same file confirms the agent's capability for shell execution, which, while plausible for a development skill, relies on an imperfect security mechanism and introduces further RCE risk.

Capability Assessment

✓ Purpose & Capability

The name/description (multi-agent development workflow) aligns with the content: spawning PM/Architect/Developer/Tester/Debugger agents and orchestrating development phases. Examples and tool choices are coherent for a development orchestration skill.

⚠ Instruction Scope

SKILL.md instructs the agent to spawn sub-agents and to operate on code, logs, and local paths (e.g., identify_modules("./legacy-code"), <logs attached>, fetch_pr). That is reasonable for a dev workflow, but the documentation also instructs installing and running remote installers (PowerShell: irm https://... | iex), which directs execution of arbitrary remote code — outside the narrow scope of 'workflow guidance' and a significant operational risk. Instructions are also somewhat vague about what environment the agent expects (what sessions_spawn/fetch_pr actually do and what permissions they require).

⚠ Install Mechanism

Although the registry has no install spec, the included tools guide explicitly recommends running remote PowerShell install commands that pipe downloaded scripts into iex (irm https://claude.ai/install.ps1 | iex and irm https://code.kimi.com/install.ps1 | iex). Executing remote installer scripts via piping to a shell is a high-risk installation mechanism. One of the URLs (claude.ai) is a known vendor domain; the other (code.kimi.com) is not verifiable here. The skill should not recommend or assume running arbitrary remote installers without verification.

ℹ Credentials

The skill declares no required env vars or credentials, and this is consistent with the registry metadata. However, the instructions reference per-user config files (~/.claude/settings.json and ~/.kimi/config.toml) and advise system prompts, and they assume external tooling that will likely require credentials or tokens at install/run time. The absence of declared required credentials means the skill does not make explicit what secrets/tools the operator must provide.

✓ Persistence & Privilege

always is false and the skill does not request system-wide config modification beyond per-user tool config files. It does not claim to modify other skills or force inclusion. No persistence/privilege escalation is declared.

Version History

v1.0.0

Initial release of "class_seven" skill: multi-agent development team workflow. - Introduces a structured, role-based orchestration for complex development tasks using specialized sub-agents (PM, Architect, Developer, Tester, Debugger). - Supports multiple workflow phases: planning, architecture/design, implementation, testing, debugging, and integration. - Includes a tool selection matrix to guide optimal agent/tool pairing based on task type. - Provides quick commands for different execution modes (full team, sprint, debug, review). - Details best practices and error handling procedures to ensure robust team collaboration and task delivery.

Metadata

Slug class-seven

Version 1.0.0

License —

All-time Installs 1

Active Installs 1

Total Versions 1

Frequently Asked Questions

What is Class Seven?

Multi-agent development team workflow skill. Use when coordinating complex development tasks requiring multiple specialized roles - PM, Architect, Developer,... It is an AI Agent Skill for Claude Code / OpenClaw, with 354 downloads so far.

How do I install Class Seven?

Run "/install class-seven" in the OpenClaw or Claude Code chat to install it in one step — no extra setup required.

Is Class Seven free?

Yes, Class Seven is completely free (open-source). You can download, install and use it at no cost.

Which platforms does Class Seven support?

Class Seven is cross-platform and runs anywhere OpenClaw / Claude Code is available (cross-platform).

Who created Class Seven?

It is built and maintained by russellfei (@russellfei); the current version is v1.0.0.

More Skills

Class Seven