playbooks

home / skills / yuniorglez / gemini-elite-core / conductor-pro

conductor-pro skill

/skills/conductor-pro

This skill coordinates multiple specialized agents to orchestrate complex workflows, reducing context switches and accelerating plan-driven project tracking.

npx playbooks add skill yuniorglez/gemini-elite-core --skill conductor-pro

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.8 KB
---
name: conductor-pro
description: Senior Progress Analyst & Conductor Strategist. Expert in Predictive Project Tracking and Agentic Milestone Management. Use this skill to orchestrate multiple specialized skills and agents in complex workflows.
---

# 🎼 Skill: conductor-pro (v1.1.0)

## Executive Summary
`conductor-pro` is the orchestration layer for the Gemini Elite Core. Its primary purpose is to prevent "Context Choice Paralysis" by intelligently selecting, activating, and sequencing the 70+ specialized tactical skills and agents. In v0.27.0, it leverages the **Event-Driven Scheduler** for ultra-low latency orchestration and manages **Persistent Plans** for long-running missions.

---

## 📋 The Conductor's Workflow
When faced with a complex task, the Conductor follows these steps:

1.  **Requirement Decomposition**: Break down the request into atomic sub-tasks.
2.  **Plan Initialization**: Trigger Plan Mode (`Shift+Tab` or `/plan`). Note that plans are automatically persisted in `~/.gemini/plans/` for session recovery.
3.  **Expert Selection**: Scan the `SKILLS_REGISTRY.md` to identify experts. Use `subagent-orchestrator` if multiple agents need to run in parallel.
4.  **Sequential Activation**: Activate skills one by one or in logical groups.
5.  **Verification**: Ensure each sub-task meets elite standards before proceeding.

---

## 🛠️ Specialized Skill Mapping (Cheat Sheet)

| Category | Recommended Skills / Agents |
| :--- | :--- |
| **Orchestration** | `subagent-orchestrator`, `conductor-pro` |
| **Architecture** | `architect-pro`, `codebase_investigator` |
| **State Management** | `zustand-expert`, `react-expert` |
| **Database** | `prisma-expert`, `db-enforcer`, `postgres-tuning` |
| **Security** | `secure-ai`, `auditor-pro`, `strict-auditor` |
| **Frontend/UI** | `ui-ux-pro`, `tailwind4-expert`, `next16-expert` |
| **Operations** | `artifact-janitor`, `vercel-sync`, `git-flow` |

---

## 🛡️ Mandatory Execution Protocols

### 1. The "Plan Persistence" Protocol
Always check for existing plans using `/plan list` if re-entering a session. The Conductor must maintain the integrity of the persistent plan file.

### 2. Proactive Delegation
If a task involves deep analysis or multi-file refactoring, **immediately** call the specialized sub-agent tool:
- `codebase_investigator(objective="...")`

### 3. Skill Chaining
Don't be afraid to chain skills. For example:
`activate_skill(name="db-enforcer")` → `activate_skill(name="prisma-expert")` → `activate_skill(name="api-pro")`.

---

## 🚦 Troubleshooting the Orchestration
- **Latency**: If orchestration feels slow, ensure `eventDrivenScheduler` is enabled in `settings.json`.
- **Context Management**: Use the `/compact` command if the context window is near its limit.

---
*Elite Core Protocol v2.5.1 - January 31, 2026*

Overview

This skill is a senior progress analyst and conductor strategist for complex, multi-agent workflows. It orchestrates expert skills, manages persistent plans for long-running missions, and prevents context-choice paralysis. It focuses on predictable progress, low-latency sequencing, and verification at each milestone.

How this skill works

The conductor decomposes high-level requests into atomic sub-tasks, initializes a persistent plan, and selects the right experts from the registry. It uses an event-driven scheduler to activate skills sequentially or in parallel via a subagent orchestrator and verifies outputs before advancing. Plans persist to disk for session recovery and the conductor adapts behavior when context windows approach limits.

When to use it

  • Coordinating multi-skill or multi-agent projects with interdependent milestones
  • Managing long-running missions that require persistent plans and recovery
  • Orchestrating parallel expert agents while enforcing quality gates
  • Automating sequential workflows that need low-latency handoffs
  • Recovering or resuming complex sessions after interruptions

Best practices

  • Always initialize Plan Mode for multi-step objectives and check /plan list before resuming
  • Enable the event-driven scheduler in settings for ultra-low latency orchestration
  • Delegate heavy analysis or code work immediately to specialized subagents (e.g., codebase_investigator)
  • Chain skills deliberately—activate dependent experts in logical groups and verify results at each step
  • Monitor context window and use compacting strategies when approaching limits

Example use cases

  • Run a complex refactor: decompose tasks, call codebase_investigator, validate changes, then deploy via ops skills
  • Deliver a product roadmap: create a persistent plan, assign research, design, and implementation agents, track milestones
  • Recover an interrupted mission: reload persisted plan, resume verification checkpoints, and continue orchestration
  • Orchestrate a security audit: select auditor-pro and strict-auditor, sequence tests, and enforce remediation workflows
  • Execute a cross-discipline release: coordinate UI, API, DB, and deployment experts with automated verification

FAQ

How are plans persisted and recovered?

Plans are saved to a persistent plans directory for session recovery; check the plan list command to view and reload active plans.

What triggers parallel agent execution?

The conductor uses a subagent orchestrator when multiple independent experts are required; it groups agents logically and runs them in parallel where safe.

How do I avoid latency in orchestration?

Enable the event-driven scheduler in settings and ensure the conductor runs with that scheduler active for ultra-low latency orchestration.