agentic-design-patterns-skills

# Agentic Design Patterns Skills

A comprehensive skill library for building AI agents using proven agentic design patterns. Each skill follows the structured **DEFINE → PLAN → ACTION** workflow and is compatible with both **Gemini CLI / Antigravity** and **Claude Code**.

## Overview

This library contains **28 skills** covering the full spectrum of agentic design patterns — from foundational patterns (Prompt Chaining, Routing, Parallelization) to advanced patterns (A2A Communication, Resource-Aware Optimization, Exploration & Discovery) and appendix skills covering tools, frameworks, and reasoning engines.

All skills are implemented with:
- **Google ADK** (Agent Developer Kit) as the primary framework
- **LangChain / LangGraph** as secondary implementations
- **CrewAI** for multi-agent collaboration patterns
- **Gemini API** (`gemini-2.5-flash`) as the default LLM
- **Multilingual triggers** (English / Korean / Japanese / Chinese) for auto-activation across language preferences

## Platform Compatibility

This skill library works with both AI CLI platforms without any content modification.

| Feature | Gemini CLI | Antigravity | Claude Code |
|---------|------------|-------------|-------------|
| **Workspace skill path** | `.gemini/skills/<name>/` or `.agents/skills/<name>/` | `.agents/skills/<name>/` | `.claude/skills/<name>/` |
| **User skill path** | `~/.gemini/skills/<name>/` or `~/.agents/skills/<name>/` | `~/.agents/skills/<name>/` | `~/.claude/skills/<name>/` |
| **Auto-activation** | Semantic: model reads description and decides autonomously | Description keyword pattern matching | Semantic judgment (language-agnostic) |
| **Context loading** | Progressive disclosure — only name+description loaded until activated | Full SKILL.md loaded on match | Full SKILL.md loaded on activation |
| **Manual invocation** | `/skills link`, `gemini skills install` | `@skills/<name>/SKILL.md` reference | `/skill-name` slash command |
| **`name:` field** | Unique skill identifier | Trigger identifier | Registered as `/slash-command` name |
| **`description:` field** | When to activate (semantic match) | Trigger phrase list (keyword match) | Basis for semantic activation |
| **`version:` field** | Used | Used | Ignored silently (no error) |
| **Content compatibility** | ✅ Fully compatible | ✅ Fully compatible | ✅ Fully compatible |

> **Key insight**: Skill file content is identical across all platforms. The differences are only in **registration path**, **activation mechanism**, and **context loading strategy**.

> **Path note**: `.agents/skills/` is the cross-tool generic alias officially supported by Gemini CLI. Antigravity uses `.agents/skills/` as its standard path. Within the same scope, `.agents/skills/` takes precedence over `.gemini/skills/`.

## Quick Start

### Step 1 — Install Dependencies

```bash
# Install Python packages
pip install google-genai google-adk langchain langchain-google-genai
pip install langgraph crewai chromadb fastapi uvicorn
pip install langchain-chroma langchain-text-splitters

# Set your API key
export GOOGLE_API_KEY="your-api-key-here"
```

### Step 2 — Platform Setup

#### Gemini CLI

Gemini CLI manages skills with the `gemini skills` command and discovers them from two scopes:

**Option A — User-level install (available in all projects):**
```bash
# Link all 28 skills at once (creates symlinks in ~/.gemini/skills/)
gemini skills link /path/to/agentic-design-patterns-skills/skills

# Verify discovery
gemini skills list
```

**Option B — Workspace install (current project only):**
```bash
# Link to the project scope (.gemini/skills/ or .agents/skills/)
gemini skills link /path/to/agentic-design-patterns-skills/skills --scope workspace

# Or create symlinks manually
mkdir -p .gemini/skills
ln -s /path/to/agentic-design-patterns-skills/skills/* .gemini/skills/
```

**Option C — Install specific skills from Git:**
```bash
# Install individual skills by subdirectory
gemini skills install https://github.com/your-org/agentic-design-patterns-skills.git --path skills/prompt-chaining
gemini skills install https://github.com/your-org/agentic-design-patterns-skills.git --path skills/planning
```

**Option D — Install all skills from Git (workspace scope):**
```bash
gemini skills install https://github.com/your-org/agentic-design-patterns-skills.git --scope workspace
```

**Verify and manage skills in an interactive session:**
```
/skills list              → show all discovered skills and their status
/skills reload            → refresh after adding new skills
/skills disable planning  → temporarily disable a skill
/skills enable planning   → re-enable a disabled skill
```

#### Antigravity

```bash
# Clone the repository
git clone https://github.com/your-org/agentic-design-patterns-skills.git

# Option A — Workspace install (.agents/skills/ — cross-tool standard path)
mkdir -p .agents/skills
ln -s /path/to/agentic-design-patterns-skills/skills/* .agents/skills/

# Option B — User-level install (~/.agents/skills/)
mkdir -p ~/.agents/skills
ln -s /path/to/agentic-design-patterns-skills/skills/* ~/.agents/skills/

# Verify by typing a trigger phrase; the matching skill activates:
#   "Build a multi-step agent pipeline"   → Prompt Chaining
#   "에이전트 병렬 실행하고 싶어"          → Parallelization
```

#### Claude Code

Claude Code reads skills from `.claude/skills/`. Choose the installation scope that fits your workflow.

**Option A — Global install (available in all projects):**
```bash
# Symlink all 28 skills at once
ln -s "$(pwd)/skills/"* ~/.claude/skills/

# After this, type / in Claude Code to see all registered slash commands:
#   /prompt-chaining, /planning, /reflection, /tool-use ...
```

**Option B — Project-level install (current project only):**
```bash
# Run from the project root
mkdir -p .claude/skills
ln -s "$(pwd)/skills/"* .claude/skills/
```

**Option C — Selective install (specific skills only):**
```bash
# Register only the skills you need
ln -s "$(pwd)/skills/prompt-chaining" ~/.claude/skills/
ln -s "$(pwd)/skills/planning"        ~/.claude/skills/
ln -s "$(pwd)/skills/reflection"      ~/.claude/skills/
```

**Option D — No install, direct file reference:**
```
# Reference any skill inline without installation
@skills/prompt-chaining/SKILL.md Please design a pipeline using this skill.
```

**Optional: Claude Code-specific frontmatter fields**

The base format works as-is. To leverage additional Claude Code features, extend the frontmatter:

```yaml
---
name: planning
description: "복잡한 작업 계획", "plan complex tasks", ...
version: 1.0.0
# Claude Code-only fields below (ignored by Antigravity)
context: fork                              # Run in an isolated subagent
allowed-tools: Read, Grep, Bash(python *)  # Tools usable without a permission prompt
argument-hint: "[goal description]"        # Autocomplete hint: /planning [goal]
---
```

## Agent Complexity Levels

Every skill maps to one of four complexity levels. Use this framework to select the right patterns for your agent's scope:

| Level | Name | Characteristics | Key Skills |
|-------|------|-----------------|------------|
| **Level 0** | Core Reasoning Engine | Single-model calls, sequential decomposition, no external tools | Prompt Chaining, Reflection |
| **Level 1** | Connected Problem-Solver | Tool use, external APIs, RAG, memory integration | Tool Use, RAG, Memory Management, MCP |
| **Level 2** | Strategic Problem-Solver | Multi-step planning, adaptive decision-making, self-correction | Planning, Routing, Guardrails, Evaluation |
| **Level 3** | Collaborative Multi-Agent | Multiple specialized agents, inter-agent communication protocols | Multi-Agent Collaboration, A2A, Parallelization |

> **Start at Level 0, add complexity only when needed.** Most production agents operate at Level 1–2.

## Skill Directory

### Part One: Core Patterns (Chapters 1–7)

| Skill | Level | Description | When to Use |
|-------|-------|-------------|-------------|
| [Prompt Chaining](ski

[truncated…]