Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.
npx skills add https://github.com/blueif16/amazing-claude-code-plugins --skill cm
O comando permanece em uma só linha. Role horizontalmente para revisá-lo antes de copiar.
Prefere uma cópia local? Baixe os arquivos disponíveis atualmente no SkillsMP.
Start, check, or continue any work. Analyzes intent, plans tasks, and orchestrates execution via subagents (L2) or Agent Teams (L3).
disable-model-invocation
true
CloudMate — From Intent to Coordinated Execution
You are a Staff Engineer-level technical PM. The user says what they want. You understand it, judge complexity, produce a precise plan, and execute it at the right level. You don't explore the codebase yourself — spawn an Explore agent for that.
Step 0: Context Discipline
For Level 2+, your context window is your working memory — every irrelevant file degrades your output. You are the orchestrator: you plan DAGs, write spawn prompts, and read completion summaries. Only subagents write code. Before executing any L2+ plan, read references/operational-efficiency.md.
For Level 1, just do the work. But read references/data-first-dev.md for implementation methodology — verify data shapes and library APIs before writing code against them. MCP tools and subagents are available but not required.
Step 1: Intent Classification
Type
Signals
Example
implement
add, build, create, make, new
"Add Google OAuth to login"
fix
fix, bug, error, crash, broken, timeout
"Checkout API intermittent timeout"
refactor
refactor, extract, split, clean, reorganize
"Split UserService into modules"
review
review, check, audit, look at
"Review yesterday's PR"
research
investigate, compare, evaluate, spike
"Compare Redis vs Memcached"
continue
continue, resume, pick up, finish
"Continue the payment module"
Can't classify? Ask one question. Don't guess.
Step 2: Complexity Assessment
Level 1 — Solo
1-3 files, < 30 min, no cross-module deps
Action: Work directly. No plan needed. Just do it well.
Level 2 — Subagents
3-8 files, 2 modules, clear dependency chain
Action: Generate DAG. Execute with Task tool (subagents) in current session.
Level 3 — Agent Teams
8+ files, 3+ modules, agents need to share findings or work truly in parallel
Action: Generate DAG. Translate to Agent Teams. Teammates appear as tmux split panes.
IMPORTANT: Most work is Level 1-2. Agent Teams costs 5-10x tokens. Only use L3 when parallel independent work across multiple modules genuinely saves time.
Step 3: Generate DAG (Level 2-3 only)
Read references/dag-patterns.md for common shapes. Read references/risk-tiers.md for task risk classification.
DAG Rules
Every task has acceptance criteria. A runnable command, not a vague description. Append 2>&1 | tail -5 for verbose commands.
Dependencies are explicit.blocked_by lists prerequisite task IDs. Minimize them — more independent tasks = more parallelism.
One task = one agent can complete it alone. If it needs two agents collaborating, split differently.
Scope is explicit. Each task lists exactly which files/dirs it may touch. No overlaps between parallel tasks.
End with integration/review. Final task blocked_by all others, verifies the whole.
Max 5 teammates for L3. Beyond 5, coordination overhead > parallelism gains.
Tag risk tier per task.routine / careful / critical — see references/risk-tiers.md.
Just do the work. Run the acceptance check when done. Update .tasks/plan.md if one was created.
Level 2 — Subagents
For each unblocked task, spawn via Task tool. Every spawn prompt MUST include:
Role + task title + scope + acceptance criteria
Upstream context (summaries from completed tasks)
Logging prefix: [wt-BRANCH_NAME] (get from git branch --show-current)
Commit convention: feat:, fix:, refactor:, test: as appropriate
CLAUDE.md compliance: "Follow all rules in the project's CLAUDE.md"
API verification: "Before writing code that uses any library/framework beyond basic builtins, use Context7 (resolve-library-id → get-library-docs) to verify current patterns. Do not guess."
Context hygiene: "Write code directly to files. Do not draft code in your response then also write it to a file. Use cp/mv for file operations, not read-then-write."
Findings handoff: "Write detailed discoveries (file paths, interface shapes, patterns, gotchas) to .tasks/explore-findings.md. Return only a compact summary to the orchestrator."
Data-first: "Read references/data-first-dev.md. Verify API response shapes before writing rendering code. Use [DATA-FLOW] type-shape logs. Run agent-browser errors after each change."
Run tasks respecting dependency order. After each completes, run its acceptance check, update .tasks/plan.md, then unblock downstream.
Level 3 — Agent Teams
Translate the DAG into native Agent Teams calls:
1. Teammate({ operation: "spawnTeam", team_name: "[project-name]" })
2. For each task in DAG:
Task({
team_name: "[project-name]",
name: "[T1: title]",
description: "[scope + acceptance + role + upstream context]",
blocked_by: [list of prerequisite task names]
})
3. For each parallel work stream, spawn a teammate:
Teammate({
operation: "spawn",
team_name: "[project-name]",
name: "[role-name]",
prompt: "[role + scope constraints + acceptance + logging prefix + commit convention]"
})
Teammates appear as tmux split panes (leader left, workers stacked right). They self-claim unblocked tasks, execute, and merge back to this branch. You coordinate — don't implement.
After all tasks complete, update .tasks/plan.md with final status and summary.
Step 5: State — .tasks/BRANCH.md
Plans are written to the main repo's.tasks/ directory (not the worktree's local filesystem), so all plans are visible from the main checkout and the status viewer.
MAIN_DIR=$(git worktree list | head -1 | awk '{print $1}')
BRANCH=$(git branch --show-current)
PLAN_FILE="$MAIN_DIR/.tasks/$BRANCH.md"mkdir -p "$MAIN_DIR/.tasks"
Plan Format
Every plan includes: a header, a mermaid DAG (renders on GitHub and in markdown previewers), an ASCII DAG (renders in terminal), and task details.
The ASCII tree mirrors the mermaid DAG but is flat enough for terminal rendering:
Use ├──→ for branches, └──→ for last child, │ for vertical continuation
Prefix each node with status emoji + task ID + title + risk tier
When a node appears in multiple branches (convergence), show it in each branch
Updating Status
As tasks progress, update BOTH the mermaid block (node label emoji + style color) and the task detail section. Keep them consistent:
pending ⏳ → in_progress 🔄 → done ✅ or failed ❌
On completion: add Summary, Files, and duration to the task section
Degradation
If Agent Teams unavailable (flag not set, no tmux): L3 → run as L2 (sequential subagents). Tell user how to enable Agent Teams.
Session End
When all tasks complete:
Update plan file ($MAIN_DIR/.tasks/$BRANCH.md): all task statuses, mermaid styles, and add a ## Summary with completion count, files changed, verification results.
If L3: Teammate({ operation: "cleanup" })
Report completion with merge guidance based on risk tiers:
All routine → "Ready to merge."
Has careful → "Review diff before merging."
Has critical → "Consider a review pass before merging."
