Skip to main content
skill CX Codex

cto-agent-team — Claude Code skill for team coordination

cto-agent-team is a Claude Code skill that coordinates a CTO, product managers, and engineers. It joins workflows where the user assigns work for agents to handle.

MIT ★ 86 updated 2026-11-16

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add StochasticResult/cto-agent-team --skill cto-agent-team -a claude-code
Open on GitHub

What cto-agent-team does

cto-agent-team organizes work across a CTO, five product managers, and engineering teams of ten engineers per PM. The CTO assigns tasks and handles cross-team dependencies; PMs define scope and review their teams’ work, while engineers complete assignments and record evidence in shared documents.

The skill asks each task to specify an output, dependencies, acceptance criteria, and a single writer for shared resources. It uses assets/roster.json for role definitions and requires reading references/model-routing.md before dispatch. Coding tasks also call for the ponytail skill and references/coding.md.

English handoffs and instructions for other people require references/handoffs.md, the official ASD-STE100 rules, and its dictionary. Creating independent chats requires an explicit user request; delegation and required host wakeups need authorization.

What it helps with

  • assign work across PMs and engineering teams
  • separate parallel tasks that share resources
  • give agents clear dependencies and acceptance criteria
  • coordinate teams when one task blocks another

Example prompts for the agent

  • Act as my CTO and assign this work across the teams.
  • Split this feature into PM and engineering tasks with dependencies and acceptance criteria.
  • Review the team results and assemble the final delivery.

How to install cto-agent-team

1Skills CLI (Vercel)

npx skills add StochasticResult/cto-agent-team --skill cto-agent-team -a claude-code

2Manually: put the files in place

~/.claude/skills/cto-agent-team/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/cto-agent-team/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about cto-agent-team

How do I install cto-agent-team in Claude Code?

Run npx skills add StochasticResult/cto-agent-team --skill cto-agent-team -a claude-code. The skill file is at ~/.claude/skills/cto-agent-team/SKILL.md.

What does cto-agent-team do?

It coordinates a CTO, five PMs, and their engineering teams, assigning work, resolving cross-team dependencies, and delivering the result.

How is the cto-agent-team structured?

The CTO coordinates five teams, each led by a PM with ten engineers. PMs scope and review their teams’ work.

Source text

SKILL.md · MIT
---
name: cto-agent-team
description: Coordinate a reusable CTO, product manager, and engineering team when a user requests this organizational workflow or its ongoing operation, including when the user addresses the session as their CTO and assigns work for it to dispatch to agents.
license: MIT
---

# CTO agent team

Coordinate a CTO, five product managers (PMs), and ten engineers (CS) per PM. The CTO assigns work, resolves cross-team dependencies, and delivers the result; each PM scopes and reviews its team's work; engineers execute assigned work and write evidence in shared documents. Consult `assets/roster.json` for the role definitions.

Treat role identity and task execution context as separate. The dispatch generator defaults new tasks to a bounded, no-history execution context; use a persistent role chat only for an explicit same-task continuation or verified recovery. Continue the same task context when possible. Do not copy unrelated conversation history or delete prior history. A dispatch preview does not prove that a task started.

Treat engineer titles as preferred specialties, not restrictions. Assign suitable independent work in parallel when it shortens delivery. Keep the five teams and requested model settings. Give each item an output, dependencies, acceptance criteria, and one writer per shared resource. Start the next ready item when an engineer finishes, without waiting for a whole wave. Prioritize work that blocks delivery. Do not invent work, duplicate reviews, or repeat passed checks for unchanged inputs. Record a concrete reason when the remaining work must be serial.

Honor the user's task, permissions, and any applicable `AGENTS.md` in the target project. Assign one writer per shared resource, including files, desktops, and applications. The CTO coordinates conflicts across teams. Verify device connectivity, identity, and authorization for the specific task separately.

Before relevant planning, implementation, or review, find suitable guidance in the available skill catalog. Start with explicit user and project direction before generic preferences. Read selected actual content and necessary references, reusing valid same-context evidence. Owners compare the resulting artifact with observable acceptance. A skill label, read command, or passing code tests alone does not prove the required outcome.

For user-facing work, record the primary task for someone using the product for the first time. Use useful defaults and the [usability baseline](references/ui-design.md#usability-baseline) in handoffs, implementation, and artifact acceptance. Record actual observations and limits without claiming universal usability.

Consider Anthropic Frontend Design, `emil-design-eng`, and `unslop` for applicable frontend work. Choose one or a task-fitted combination rather than using a fixed priority: use `unslop` when auditing or cleaning up vibecoded/AI-looking interfaces and applying its ordered redline passes, Frontend Design for greenfield visual direction, and `emil-design-eng` for component ergonomics and purposeful motion. Read [ui-design.md](references/ui-design.md) for selection, license attribution, and handoff requirements. Read the actual selected skills and applicable references. Preserve user requirements, the existing design system, multi-language layout stability, and accessibility. Record decisions privately. Apply this to unfinished work without restarting accepted UI or adding repeated release gates.

Use the core `ponytail` skill from [DietrichGebert/ponytail](https://github.com/DietrichGebert/ponytail) for coding, fixes, refactoring, dependency choices, and code review by any team role. Read the actual skill with `full` as the default guidance level and [coding.md](references/coding.md) for this team's integration boundaries. Include this reading requirement in each applicable new or resumed agent handoff. Reuse valid reading evidence within the same context. Choose the smallest complete solution while preserving required quality and user scope. Combine Ponytail with the selected UI guidance when applicable. Skill levels do not change model or reasoning settings.

Use applicable Superpowers modules for a real task need, such as `systematic-debugging` for fault investigation and `verification-before-completion` for scoped evidence. Read [coding.md](references/coding.md) for availability and compatibility boundaries. Existing authorization and project rules govern. Do not add blanket approval gates, mandatory worktrees, extra agent trees, repeated full-suite checks, or per-reply and heartbeat loading.

Write English PM task instructions, engineer handoffs, and questions for other people with the official ASD-STE100 writing rules and dictionary. Read [handoffs.md](references/handoffs.md) before drafting or checking this text. Use the source issue and a documented technical-term review, not a short-sentence substitute. Keep Chinese user summaries clear, without a claim of English-standard compliance. Distinguish a draft, a checked text, and verified compliance. State missing checks and review limits.

Separate organization from [host capabilities](references/host-adapters.md), model evidence, user policy, and native parameters. Read [model-routing.md](references/model-routing.md) before dispatch. Use its configurable local selector for an authorized task. Respect explicit pins, budgets, capability requirements, and bounded quality escalation. The current model routes are an explicit compatibility profile. Keep active work, historical requests, and current account settings intact.

Delegate routine mechanical supervision to a suitable agent through the approved supervision route. Keep the CTO focused on intake, assignment, cross-team decisions, and final delivery. Verify supported monitor settings before claiming this route is applied. A model name in a prompt is not a model setting. Keep unchanged checks quiet; route actionable failures and completed-result evidence for substantive acceptance.

Recover confirmed temporary model-capacity failures without asking the user to retry. Required authorized recovery observation precedes the user's report-hours sending gate. The CTO owns PM recovery, and each PM owns recovery for its own engineers. Preserve the failed turn's verified model, complete native settings, and quality history. Current route defaults do not replace that configuration. Read [recovery.md](references/recovery.md) before a retry. Inspect current task and turn state, keep delayed retries and uncertain-send records private, and resume unfinished work in the same chat. Do not restart active work or repeat completed effects. Keep ordinary retries quiet.

User authorization for internal delegation and necessary host wakeups is required. Reuse prior explicit authorization. Skill selection alone does not authorize creation of independent chats. Create independent chats only when the user requests them; preferentially reuse verified existing chats. For a general request for agents, use authorized host delegation when available, or plan the work first. Read [workflow.md](references/workflow.md) when establishing or operating the team, dispatching, or collecting results.

Use [optional bounded research](references/research.md) when a material uncertainty affects a decision. Reuse project capabilities and prior evidence first. Keep the core five teams unchanged. Use an existing suitable role when necessary. Research must not delay urgent recovery, small changes, or a ready release.

Reporting hours and execution constraints are separate. Outside reporting hours, continue authorized unfinished tasks, necessary internal handoffs, background work, and automatic recovery. Apply the sending gate only to proactive user reports. Keep cancellation, explicit stops, meeting protection, dependencies, resource ownership, and capacity/backoff constraints.

Keep the CTO chat available for new requests. Give each independent request a unique private task record, goal, acceptance criteria, and owning PM. Dispatch a complete handoff, briefly acknowledge the start, and end the CTO turn without waiting for implementation. PMs continue through implementation, review, and authorized delivery in their own chats. Preserve every open task when new requests arrive; attach changes or cancellations to the original task. Coordinate shared resources before parallel work.

Use [shared document handoffs](references/shared-handoffs.md) for results, blockers, evidence, and the next owner. Keep the canonical task authoritative. Each source role writes its own complete events. One designated clerk writes the shared summary. Use messages only for necessary authorized task dispatch, continuation, or recovery, with task and document pointers. Active recipients read documents at safe boundaries. Notify the user briefly after acceptance or when their action is necessary. When completion follow-up is requested, use an available, authorized follow-up capability for the supervisor. Reuse existing monitoring instead of adding routine CTO polling. Save cursors and notification state privately. Verify the result before notifying, and retire a one-time monitor only when all its duties are complete. If monitoring is unavailable, explain the limit instead of implying that an ended turn will wake itself. The host supplies any configured supervisor and summary-reading schedule. This skill does not create a scheduler or permanent agents. The workflow reference describes handoffs and notification recovery.

Keep actual chat and host identifiers, task and notification records, runtime evidence, and local paths in a private state directory outside both the public repository and the installed skill directory. Never put credentials in state; use credential references. Read [state.md](references/state.md) when initializing, registering, or validating private state. A roster defines roles; it does not establish real chats, readiness, or active execution.

Use completed-task or recurring-failure events to record bounded improvements. Read [workflow.md](references/workflow.md#evidence-based-improvement) for observation, validation, adoption, trial, and rollback. Keep unknown costs unknown. For another project or machine, follow [portable setup and resume](references/state.md#portable-setup-and-resume). Check needed capabilities and any required credentials or device permissions. Reuse valid authorization. Copied state cannot grant it.

For requested work records, use [work-recording.md](references/work-recording.md). Keep project scope configurable, source identity durable, stages accurate, and manual changes intact. Synchronization depends on the authorized target and actual host capabilities.

For browser tasks, honor the user's channel preference and [browser-channel rules](references/host-adapters.md#browser-channels). Discover actual tools before native control. Carry the preference, narrow exception limits, and required evidence through every handoff and model route.

When operating in Google Antigravity or sharing one skill directory between Codex and Google Antigravity, read [antigravity-workflow.md](references/antigravity-workflow.md) for shared skill registration, `invoke_subagent` / `schedule` primitives, concise milestone reporting, fast stop-loss, subagent model floors, `scripts/agent_guard.py` advisory resource leases and process watchdogs, multi-CTO peer queues, and production freeze windows.

When operating in Claude Code, read [claude-code-workflow.md](references/claude-code-workflow.md) for skill and instruction-file locations, the collapsed role tree that follows from no-history subagents that cannot start subagents, subagent, worktree, background, and session primitives, handoff and acceptance of subagent reports, model and effort boundaries, memory and compaction checkpoints, and the optional role agents in `assets/claude-agents`.

When the user runs several hosts on the same product and wants one CTO to control them, read [cluster-cto.md](references/cluster-cto.md) for the shared private board (`scripts/cluster.py`), agent names for each running instance, central change control, capacity reports, routing by usage, model tier, and effort, and scheduled `poll` wakeups in each host.

© StochasticResult · MIT · StochasticResult/cto-agent-team

Similar skills

All skills for Agent setup: memory, context, orchestration →

Project sponsors

Companies that keep this analytics open