cli-claude-code: Teaching Other AIs to Call Claude When They're Out of Their Depth

13 stars on SkillsMP with zero movement in the last week. That's not a viral hit — but it's also not noise. Skills like this tend to accumulate a quiet, loyal audience of developers who actually need them, rather than developers who think they might need them someday. I installed it, read the source, and ran it through some real scenarios. Here's what I found.

What This Skill Actually Does

The pitch sounds almost paradoxical at first: it's a skill for Claude Code that tells Claude Code how to be invoked by other AIs. Specifically, it's an orchestration layer that lets Gemini CLI, Codex CLI, GitHub Copilot, or any other external AI assistant shell out to Claude Code's CLI (claude) for tasks where Claude has a meaningful edge.

The core idea is that your calling AI — say, Gemini — stays the conductor. When it hits something that benefits from Claude's extended thinking, precise code editing, or JSON-schema-validated output, it delegates that subtask to Claude via CLI, waits for the result, and integrates it back into its own workflow.

It's essentially a subprocess.run(["claude", ...]) wrapper with a lot of opinionated scaffolding around when and how to use it.

Why This Matters

If you're living entirely inside Claude Code, this skill does nothing useful for you — and the author is upfront about this. There's an explicit self-invocation guard that checks for the $CLAUDECODE environment variable and bails out if you're already inside a Claude session. That's good engineering hygiene.

But if you're running multi-AI workflows — and more developers are, whether they admit it or not — this fills a real gap. Different models have different strengths. Gemini has strong web grounding and a massive context window. Codex is tightly integrated with certain toolchains. Claude has arguably the best extended reasoning and the most reliable structured output behavior among the current generation of coding assistants.

The problem is that switching between them manually is friction. You context-switch, re-explain, copy-paste. This skill tries to automate that delegation pattern so the right model handles the right subtask without you babysitting the handoff.

Key Capabilities Worth Knowing About

1. The self-invocation guard is the most important feature nobody will talk about.

Seriously. The fact that the skill detects whether it's running inside a Claude Code session and refuses to proceed is the thing that separates thoughtful tool design from a footgun. Circular delegation — Claude calling Claude via CLI — would burn tokens, add latency, and produce no value. The guard is simple ([ -n "$CLAUDECODE" ]) but it shows the author thought about failure modes.

2. Intent scoring with weighted routing.

The skill includes a pseudocode router that scores incoming task descriptions against seven intent categories: deep reasoning, code editing, structured output, review, agent delegation, templates, and patterns. Each category maps to a different set of reference documents to load. This isn't just documentation — it's a specification for how the calling AI should decide whether to delegate and what context to pass along.

In practice, this means the skill is self-documenting in a useful way. Reading the INTENT_SIGNALS dictionary tells you exactly when the author thinks Claude Code adds value over a generic LLM call.

3. Structured output with --json-schema is the sleeper use case.

The skill specifically calls out JSON schema validation as a first-class delegation trigger. If you need guaranteed-structure output for pipeline integration — say, extracting dependency graphs, generating typed config, or producing analysis results that feed into another tool — Claude's --json-schema flag is genuinely useful and not something every AI CLI exposes cleanly. This skill documents the pattern for invoking it correctly.

4. Cost control via --max-budget-usd.

Background processing tasks include guidance on using Claude Code's budget flag to cap spend on long-running analysis. This is the kind of practical detail that's easy to overlook when you're designing orchestration workflows and then painful when your API bill arrives.

5. The broader Spec Kit context.

This skill is part of a larger framework — 12 agents, 20 skills, 52 MCP tools, persistent memory via MCP server. The cli-claude-code skill is one component in a multi-runtime system designed around OpenCode but mirrored to Codex CLI, Claude Code, and Gemini CLI. You don't need the whole framework to use this skill, but understanding that it exists in that context explains some of the design decisions. The reference files it loads (references/cli_reference.md, references/integration_patterns.md, etc.) are part of the broader Spec Kit, not bundled with just this skill.

Who Should Install This

Install it if: - You're running Gemini CLI or Codex as your primary coding assistant and want to delegate specific subtasks to Claude without manual context-switching - You're building multi-agent workflows and need a documented, opinionated pattern for cross-AI delegation - You care about structured output and want a reference for Claude's --json-schema invocation - You're already exploring the broader MichelKerkmeester Spec Kit framework

Skip it if: - Claude Code is your only AI assistant — you get nothing from this - You're looking for a simple, self-contained skill with no external dependencies - You're not comfortable with the idea that this skill's reference files live in a larger repo structure you'd need to pull separately - You want something that works out of the box with zero configuration

How to Install

This skill lives inside the larger opencode--spec-kit-skilled-agent-orchestration repo. You can grab just the skill directory:

# Clone the full repo and copy the skill
git clone https://github.com/MichelKerkmeester/opencode--spec-kit-skilled-agent-orchestration
cp -r opencode--spec-kit-skilled-agent-orchestration/.opencode/skill/cli-claude-code ~/.claude/skills/

Or if you want the full context (and the reference files the skill loads), you're better off working within the repo structure directly. The skill references files at relative paths like references/cli_reference.md — those won't exist if you just drop the SKILL.md into your skills directory in isolation.

That's actually my biggest practical concern with the installation story, which I'll get to next.

Concerns and Limitations

The reference file dependency is a real issue. The skill's smart router loads context from references/cli_reference.md, references/integration_patterns.md, references/claude_tools.md, and references/agent_delegation.md. If those files aren't present relative to the skill, the routing logic degrades to a no-op. The skill is not self-contained. You either install the full Spec Kit or you accept that the conditional resource loading won't work.

It's a specification, not executable code. The Python pseudocode in the routing section is illustrative — it describes what the AI should do, not what actually runs. This is fine for a skill (that's how SKILL.md files work), but developers expecting a drop-in CLI wrapper will be confused. The "code" is instructions for the AI, not a script you run.

Cross-AI orchestration adds real latency. Shelling out to claude from another AI's context means you're paying for two model invocations plus CLI startup time. For quick tasks, this overhead is not worth it. The skill acknowledges this in the "when NOT to use" section, but it's worth internalizing: this pattern is for tasks where the quality delta justifies the round-trip cost.

13 stars is a small signal. The skill is at version 1.1.3, which suggests active iteration, but the community adoption is limited. That's not a dealbreaker — niche tools often have small audiences — but it means you're closer to the bleeding edge than the well-trodden path. Expect to debug edge cases yourself.

No test coverage or validation examples. I'd love to see concrete before/after examples of a Gemini CLI session delegating to Claude and integrating the result. The documentation is thorough on the what but thin on the here's what it looks like when it actually works.

Verdict

This is a well-designed skill for a specific, real use case. If you're running multi-AI workflows and you want an opinionated, documented pattern for delegating to Claude Code from another assistant, this is worth your time. The self-invocation guard alone shows the author understands the failure modes.

But it's not for everyone. It requires the broader Spec Kit context to work properly, it adds latency by design, and it solves a problem you might not have yet. If you're a single-AI developer working entirely in Claude Code, close this tab.

For the developers building actual multi-agent pipelines — the ones who've already felt the pain of manually context-switching between Gemini and Claude for different task types — this skill gives you a solid foundation to build on.

Install it: SkillsMP page

Read the source: GitHub