playbooks

home / skills / yeachan-heo / oh-my-claudecode / ccg

ccg skill

/skills/ccg

This skill orchestrates Claude, Codex, and Gemini to decompose, parallelize tasks, and synthesize a cohesive backend and frontend solution.

npx playbooks add skill yeachan-heo/oh-my-claudecode --skill ccg

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

Files (1)
SKILL.md
2.7 KB
---
name: ccg
description: Claude-Codex-Gemini tri-model orchestration via /ask codex + /ask gemini, then Claude synthesizes results
---

# CCG - Claude-Codex-Gemini Tri-Model Orchestration

CCG routes through the canonical `/ask` skill (`/ask codex` + `/ask gemini`), then Claude synthesizes both outputs into one answer.

Use this when you want parallel external perspectives without launching tmux team workers.

## When to Use

- Backend/analysis + frontend/UI work in one request
- Code review from multiple perspectives (architecture + design/UX)
- Cross-validation where Codex and Gemini may disagree
- Fast advisor-style parallel input without team runtime orchestration

## Requirements

- **Codex CLI**: `npm install -g @openai/codex` (or `@openai/codex`)
- **Gemini CLI**: `npm install -g @google/gemini-cli`
- `omc ask` command available
- If either CLI is unavailable, continue with whichever provider is available and note the limitation

## How It Works

```text
1. Claude decomposes the request into two advisor prompts:
   - Codex prompt (analysis/architecture/backend)
   - Gemini prompt (UX/design/docs/alternatives)

2. Claude runs:
   - /oh-my-claudecode:ask codex "<codex prompt>"
   - /oh-my-claudecode:ask gemini "<gemini prompt>"

   (equivalent CLI path: `omc ask codex ...` + `omc ask gemini ...`)

3. Artifacts are written under `.omc/artifacts/ask/`

4. Claude synthesizes both outputs into one final response
```

## Execution Protocol

When invoked, Claude MUST follow this workflow:

### 1. Decompose Request
Split the user request into:

- **Codex prompt:** architecture, correctness, backend, risks, test strategy
- **Gemini prompt:** UX/content clarity, alternatives, edge-case usability, docs polish
- **Synthesis plan:** how to reconcile conflicts

### 2. Invoke ask skills

Use skill routing first:

```bash
/oh-my-claudecode:ask codex <codex prompt>
/oh-my-claudecode:ask gemini <gemini prompt>
```

Equivalent direct CLI:

```bash
omc ask codex "<codex prompt>"
omc ask gemini "<gemini prompt>"
```

### 3. Collect artifacts

Read latest ask artifacts from:

```text
.omc/artifacts/ask/codex-*.md
.omc/artifacts/ask/gemini-*.md
```

### 4. Synthesize

Return one unified answer with:

- Agreed recommendations
- Conflicting recommendations (explicitly called out)
- Chosen final direction + rationale
- Action checklist

## Fallbacks

If one provider is unavailable:

- Continue with available provider + Claude synthesis
- Clearly note missing perspective and risk

If both unavailable:

- Fall back to Claude-only answer and state CCG external advisors were unavailable

## Invocation

```bash
/oh-my-claudecode:ccg <task description>
```

Example:

```bash
/oh-my-claudecode:ccg Review this PR - architecture/security via Codex and UX/readability via Gemini
```

Overview

This skill implements a Claude-Codex-Gemini tri-model orchestration pattern that decomposes developer requests, runs backend and frontend work in parallel, and synthesizes a unified implementation. It is teams-first and designed for multi-agent code workflows where Claude acts as conductor, Codex handles backend/code tasks, and Gemini handles UI/design tasks. The pattern emphasizes parallel execution, clear role assignment, and a final integration step to reconcile interfaces and cross-cutting concerns.

How this skill works

On trigger, Claude immediately announces CCG mode, decomposes the request into backend, frontend, and synthesis tasks, and fans out parallel jobs: Codex (backend) and Gemini (frontend) run in background mode via MCP tools. Claude waits for both outputs, reconciles conflicts (API shapes vs component props), applies cross-cutting concerns (typing, auth, error handling), and emits integration glue code and a cohesive deliverable. If an MCP is unavailable, defined fallback subagents are used to preserve flow.

When to use it

  • Building a full-stack feature that requires coordinated API and UI work
  • Adding endpoints, data models, or security changes alongside React/Vue components
  • Refactoring where API shapes and component props must be reconciled
  • Parallelizing work to speed delivery while keeping a single orchestrator
  • Generating design-forward UI with large-context needs plus backend code

Best practices

  • Clearly describe backend vs frontend responsibilities in the initial prompt
  • Include relevant source files for context so Codex/Gemini can run independently
  • Choose appropriate agent roles (architect, designer, security-reviewer) for each task
  • Use background execution and wait_for_job to avoid blocking the orchestration
  • Review synthesized output for edge cases like auth flows, types, and error boundaries

Example use cases

  • Add a REST endpoint and a React user profile page with matching props and types
  • Create a new database model, migration, endpoint, and admin UI component in parallel
  • Perform a security audit on APIs while iterating on component styling and layout
  • Refactor API responses and update consuming UI components with a single integration pass
  • Produce design assets and long-context documentation for a complex UI while wiring backend services

FAQ

What happens if Codex or Gemini MCP is unavailable?

Fallback subagents are used: an oh-my-claudecode executor for backend or designer for frontend; if both are unavailable, Claude handles tasks directly.

How are conflicts between API shapes and component props resolved?

Claude synthesizes both outputs, reconciles types and shapes, and emits glue code such as adapters, fetch hooks, or prop transformations.