Gemini CLI vs Claude Code for AI Agent Skills

Google's Gemini CLI added SKILL.md support last month. This puts it in direct competition with Claude Code for running AI agent skills. Both tools load skills from markdown files, but they handle context, memory, and developer workflow very differently.

I've been testing both extensively. Here's what matters for building and running skills.

Loading and execution speed

Gemini CLI parses SKILL.md files faster than Claude Code handles CLAUDE.md. Cold starts take 1.2 seconds versus 2.8 seconds on my M2 MacBook. The difference becomes noticeable when you're iterating on skill development.

Claude Code compensates with better warm restarts. Once a conversation is active, subsequent skill loads happen almost instantly. Gemini CLI re-parses everything each time.

Both tools support the standard skill format, but Gemini CLI is stricter about markdown syntax. Missing backticks or malformed YAML frontmatter will cause hard failures. Claude Code is more forgiving and often continues with partial parsing.

Context window handling

This is where the tools diverge significantly.

Claude Code maintains full conversation context across skill executions. If you load a data analysis skill, run it on some CSV data, then load a visualization skill, the second skill can reference the first skill's output naturally. The context flows between skills like a continuous conversation.

Gemini CLI treats each skill execution as isolated by default. You need to explicitly pass context between skills using the --context flag or save intermediate results to files. This is cleaner for debugging but requires more manual orchestration.

gemini-cli run analysis.skill.md --input data.csv --output results.json
gemini-cli run visualize.skill.md --context results.json --input chart_config.yaml

For complex workflows involving multiple skills, Claude Code's persistent context is significantly easier to work with. For single-purpose skills that run independently, Gemini CLI's isolation prevents unexpected side effects.

Memory and state management

Claude Code keeps everything in memory until the conversation ends. This means no intermediate files cluttering your workspace, but also no persistence across sessions. Close the conversation and your analysis state disappears.

Gemini CLI writes intermediate outputs to disk by default. This creates more files but gives you proper resumability. You can pick up a multi-step workflow days later exactly where you left off.

The SKILL.md spec supports both approaches through optional configuration blocks, but the tools implement them differently.

Error handling and debugging

Gemini CLI provides better error messages. When a skill fails, you get the exact line number, the problematic YAML or code block, and a suggestion for fixing it. The error output includes the full skill parsing trace.

Claude Code's error messages are more conversational but less specific. Instead of "YAML parse error at line 23", you might get "There seems to be an issue with the configuration section." This matches Claude's general interaction style but makes debugging harder.

Both tools support verbose logging modes, but Gemini CLI's structured output works better for automated testing and CI/CD integration.

Skill ecosystem integration

Claude Code has better integration with the existing MCP servers ecosystem. Many MCP tools work seamlessly as skill dependencies without modification. The skill can call MCP functions directly from within code blocks.

Gemini CLI requires explicit MCP bridge configuration. You define MCP connections in the skill's frontmatter, then reference them in code blocks. This adds setup overhead but gives you more control over which services each skill can access.

mcp_connections:
  - name: filesystem
    server: "npx @modelcontextprotocol/server-filesystem"
    tools: ["read_file", "write_file"]

For developers already using MCP extensively, Claude Code requires less configuration. For new projects, Gemini CLI's explicit dependency model prevents accidental skill coupling.

Developer experience differences

Gemini CLI feels more like a traditional CLI tool. You install skills locally, version them with git, and run them with explicit commands. The workflow matches what developers expect from other command-line utilities.

gemini-cli install github.com/user/repo/skills/data-analysis.skill.md
gemini-cli list
gemini-cli run data-analysis --help

Claude Code embeds skills into conversations organically. You paste the skill markdown into a chat, and it becomes part of that conversation's capabilities. This feels natural but makes skill sharing and version control more complex.

Both support the skill best practices around modular design and clear interfaces, but they encourage different development patterns.

Performance under load

I tested both tools with a batch of 50 data processing skills running simultaneously. Gemini CLI handled the load better, maintaining consistent response times around 3-4 seconds per skill execution. Memory usage stayed stable at around 200MB.

Claude Code struggled with parallel execution. Response times increased linearly with the number of concurrent conversations. At 20+ parallel skills, response times degraded to 15-20 seconds and memory usage spiked above 1GB.

For automated workflows or API integration use cases, Gemini CLI's resource management is clearly superior.

When to choose which tool

Use Gemini CLI when you need:

Reproducible skill execution across team members
Integration with existing CLI toolchains
Parallel skill processing
File-based intermediate results
Strict error handling for production use

Use Claude Code when you need:

Conversational skill interaction
Context flow between multiple skills
Rapid skill prototyping and testing
Integration with existing MCP setups
Natural language workflow orchestration

The bigger picture

Both tools validate that skills are becoming a standard way to package AI capabilities. The SKILL.md spec gives developers a common format regardless of execution environment.

Gemini CLI pushes skills toward traditional software development practices: versioning, testing, deployment pipelines. Claude Code keeps skills closer to conversational AI interactions: exploratory, contextual, adaptive.

Neither approach is inherently better. They serve different parts of the AI development lifecycle. Many teams will end up using both: Claude Code for exploration and prototyping, Gemini CLI for production deployment.

The real winner is the growing skills ecosystem. As more developers publish reusable skills, having multiple compatible execution environments increases adoption and experimentation.