One-click install
npx skills add https://github.com/xz1220/oh-my-kimi --skill team-xz1220
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: team
Source: https://github.com/xz1220/oh-my-kimi/tree/main/skills/team
Command: npx skills add https://github.com/xz1220/oh-my-kimi --skill team-xz1220

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It solves the problem of breaking a large work item into parallelizable subtasks and coordinating multiple AI agents to execute, verify, and iteratively fix until completion.

Core Features & Use Cases

  • Multi-agent phased orchestration: Runs a standardized pipeline (team-plan → team-prd → team-exec → team-verify → team-fix loop) with stage-specific specialist agents.
  • Shared task list with dependencies: Creates N worker tasks, assigns owners, tracks status, and enforces blockedBy/blocked task dependencies so work doesn’t race ahead.
  • Verification and iterative repair: Uses verifier + reviewers, routes failures into fix loops with bounded retry behavior (and supports Team + Ralph persistence when requested).
  • Flexible worker routing (optional): Lets you choose worker type for the team-exec stage (e.g., executor/debugger/designer/writer/codex/gemini), while other phases use their own experts.

Quick Start

Tell your team to implement and coordinate the work by saying: /team 4:executor "refactor the auth module with security review"

Frequently Asked Questions about team

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I coordinate multiple AI agents to execute a complex software engineering task?

You can coordinate multiple AI agents by using a phased pipeline that breaks complex software engineering tasks into parallel subtasks, assigning specialized agents to plan, execute, verify, and iteratively fix code.

What is the best way to manage task dependencies and prevent racing during parallel multi-agent execution?

Managing task dependencies during parallel execution requires a shared task list that tracks ownership and enforces blockedBy constraints, ensuring downstream modules wait for prerequisite work to finish.

How does iterative code fixing work in an automated verification and repair pipeline?

Iterative code fixing in an automated pipeline works by routing verification failures from specialized reviewers into a bounded fix loop, applying repeated corrections until tests pass or retries exhaust.

Can I route specific subtasks to different types of AI workers like debuggers or designers?

You can route subtasks to different AI workers by specifying worker types for the execution stage, allowing you to assign specialized agents like executors, debuggers, designers, or codex to targeted work items.

Do I need Kimi CLI to orchestrate multi-agent task pipelines?

You need Kimi CLI for multi-agent task orchestration because the pipeline relies on its native SendMessage-based coordination to manage worker ownership and route communication between specialized agents.

How do I persist task states and retries for a long-running multi-agent pipeline?

To persist task states and retries for a long-running pipeline, you can integrate Ralph for persistence, maintaining shared task list status and bounded retry behavior across execution stages.