team

Decompose multi-file software tasks into parallel git worktree workstreams.

82|23|Updated Feb 24, 2026
One-click install
npx skills add https://github.com/Rune-kit/rune --skill team-rune-kit
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: team
Source: https://github.com/Rune-kit/rune/tree/main/skills/team
Command: npx skills add https://github.com/Rune-kit/rune --skill team-rune-kit

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill tackles large, complex tasks that involve multiple files or modules by breaking them down into smaller, parallelizable workstreams, significantly speeding up development and reducing the cognitive load on the developer.

Core Features & Use Cases

  • Task Decomposition: Intelligently splits large tasks into independent sub-tasks.
  • Parallel Execution: Assigns sub-tasks to isolated "cook" instances using git worktrees for safe, concurrent development.
  • Conflict Resolution & Merging: Manages the merging of parallel workstreams, resolving conflicts and ensuring code integrity.
  • Use Case: When asked to implement a new feature that touches the user authentication, database layer, and UI components, the team skill can decompose this into three parallel tasks, allowing them to be developed and tested concurrently.

Quick Start

Use the team skill to parallelize the implementation of the new user profile page across the frontend, backend, and database modules.

Frequently Asked Questions about team

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

FAQPage Schema
How do I parallelize multi-file software development tasks across isolated git worktrees?

Parallel multi-file software development is orchestrated by decomposing complex tasks into independent workstreams, assigning them to isolated git worktrees for concurrent execution, and managing the final merging to ensure code integrity.

When do I need multi-agent task decomposition for my coding workflow?

Multi-agent task decomposition is needed when a complex implementation spans 5 or more files or 3 or more modules, requiring the breakdown of large features into smaller, parallelizable sub-tasks to reduce cognitive load and speed up development.

How does conflict resolution work when merging parallel code orchestration workstreams?

Conflict resolution during code orcheststration merging is managed by the workflow coordinator, which handles progress coordination across parallel instances and resolves git conflicts to ensure code quality and integrity upon final merge.

Can I use this parallel execution workflow for a feature touching frontend, backend, and database modules?

Parallel execution workflows support features touching frontend, backend, and database modules by intelligently splitting the task into three independent sub-tasks, allowing them to be developed, tested, and merged concurrently in isolated worktrees.

What are the limitations of using git worktrees for multi-agent code orchestration?

Git worktree multi-agent orchestration is limited by the complexity of conflict resolution during merging, requiring robust mesh resilience patterns to handle workflow execution failures and ensure code quality across concurrent development branches.