claude-deep-expert

Category: 数据与AI | Uploader: eovidiu | Downloads: 0 | Version: v1.0（Latest）
Deep expert on the Claude platform — models, APIs, SDKs, AWS Bedrock, Google Vertex AI, Claude Code CLI, prompt engineering, and MCP. Provides precise, opinionated guidance with exact API shapes, model IDs, code examples, and trade-off analysis. Use when configuring Claude on Bedrock, choosing models, designing API integrations, optimizing prompts, or architecting with Claude Code. Trigger phrases include "how do I configure Claude on Bedrock", "what's the right model for X", "Claude API", "Vertex AI Claude", "Claude Code setup".
Changelog: Source: GitHub https://github.com/eovidiu/agents-skills
Directory Structure

Current level: claude-deep-expert/
📁 references/
- 📄 anthropic-api.md 23.4 KB
- 📄 aws-bedrock.md 10.3 KB
- 📄 claude-code-cli.md 13.4 KB
- 📄 google-vertex.md 10.8 KB
- 📄 model-selection.md 7.4 KB
- 📄 prompt-engineering.md 16.2 KB
- 📄 sdks.md 22.2 KB
📄 SKILL.md 11.9 KB
SKILL.md

---
name: claude-deep-expert
description: Deep expert on the Claude platform — models, APIs, SDKs, AWS Bedrock, Google Vertex AI, Claude Code CLI, prompt engineering, and MCP. Provides precise, opinionated guidance with exact API shapes, model IDs, code examples, and trade-off analysis. Use when configuring Claude on Bedrock, choosing models, designing API integrations, optimizing prompts, or architecting with Claude Code. Trigger phrases include "how do I configure Claude on Bedrock", "what's the right model for X", "Claude API", "Vertex AI Claude", "Claude Code setup".
---

# Claude Deep Expert

## Overview

A deep-knowledge expert on the entire Claude platform ecosystem. This skill provides precise, opinionated answers — not surface-level summaries — about Claude models, APIs, SDKs, cloud integrations, CLI tooling, and prompt engineering.

The expert knows exact API shapes, model IDs, pricing, SDK patterns, configuration variables, and platform-specific gotchas. When asked a question, it recommends a best path with trade-off analysis, not just a list of options.

## Core Capabilities

### 1. Claude Model Family

Know every model, its strengths, and when to use it:

- **Claude Opus 4.6** (`claude-opus-4-6`): Most intelligent model. 200K context (1M beta). 128K max output. $5/$25 per MTok. Best for: complex reasoning, agents, coding, deep analysis.
- **Claude Sonnet 4.6** (`claude-sonnet-4-6`): Best speed/intelligence ratio. 200K context (1M beta). 64K max output. $3/$15 per MTok. Best for: daily coding, enterprise workloads, high-volume tasks.
- **Claude Haiku 4.5** (`claude-haiku-4-5-20251001`): Fastest model. 200K context. 64K max output. $1/$5 per MTok. Best for: interactive apps, high-volume processing, cost-sensitive workloads.

All models support: vision, tool use, extended thinking, prompt caching, citations, PDF input, structured output.

**Reference**: `references/model-selection.md` — full model comparison, pricing tiers, decision framework, context window details, batch pricing.

### 2. Anthropic Messages API

Master the complete Messages API surface:

- **Endpoint**: `POST https://api.anthropic.com/v1/messages`
- **Headers**: `x-api-key`, `anthropic-version: 2023-06-01`, `content-type: application/json`
- **Request parameters**: model, messages, max_tokens, system, temperature, top_p, top_k, stop_sequences, stream, tools, tool_choice, thinking, metadata, cache_control
- **Content block types**: text, image, document (PDF/text), tool_use, tool_result, thinking, redacted_thinking
- **Response shape**: id, type, role, content[], model, stop_reason, usage
- **Streaming**: SSE events (message_start, content_block_start/delta/stop, message_delta, message_stop, ping)
- **Tool use**: Custom tools with JSON Schema, server tools (web_search, code_execution, web_fetch)
- **Extended thinking**: `thinking: { type: "enabled", budget_tokens: N }` — temperature must be 1
- **Prompt caching**: `cache_control: { type: "ephemeral" }` with 5m or 1h TTL
- **Citations**: Document-level citations with char, page, and content block locations
- **Batch API**: Async processing at 50% cost reduction
- **Structured output**: JSON Schema validation via `output_config`

**Reference**: `references/anthropic-api.md` — complete API reference with all parameter types, content blocks, streaming events, error codes, and code examples.

### 3. AWS Bedrock Integration

Configure and use Claude on Amazon Bedrock:

| Model | Base Bedrock Model ID | Global | US | EU |
|-------|----------------------|--------|----|----|
| Claude Opus 4.6 | `anthropic.claude-opus-4-6-v1` | Yes | Yes | Yes |
| Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` | Yes | Yes | Yes |
| Claude Sonnet 4.5 | `anthropic.claude-sonnet-4-5-20250929-v1:0` | Yes | Yes | Yes |
| Claude Haiku 4.5 | `anthropic.claude-haiku-4-5-20251001-v1:0` | Yes | Yes | Yes |

- **Global endpoints**: Prefix with `global.` (e.g., `global.anthropic.claude-opus-4-6-v1`) — dynamic routing, no price premium
- **Regional endpoints**: No prefix or regional prefix (e.g., `us.anthropic.claude-opus-4-6-v1`) — data residency compliance, 10% premium
- **SDK**: `pip install "anthropic[bedrock]"` / `npm install @anthropic-ai/bedrock-sdk`
- **Client**: `AnthropicBedrock(aws_region="us-west-2")` — same Messages API interface
- **Claude Code**: Set `CLAUDE_CODE_USE_BEDROCK=1` + AWS credentials
- **1M context**: Available for Opus 4.6, Sonnet 4.5, Sonnet 4 via `context-1m-2025-08-07` beta header

**Reference**: `references/aws-bedrock.md` — full Bedrock guide with model IDs, SDK examples, IAM policies, global vs regional endpoints, pricing, and Claude Code configuration.

### 4. Google Vertex AI Integration

Configure and use Claude on Google Cloud Vertex AI:

| Model | Vertex AI Model ID |
|-------|--------------------|
| Claude Opus 4.6 | `claude-opus-4-6` |
| Claude Sonnet 4.6 | `claude-sonnet-4-6` |
| Claude Sonnet 4.5 | `claude-sonnet-4-5@20250929` |
| Claude Haiku 4.5 | `claude-haiku-4-5@20251001` |

- **SDK**: `pip install "anthropic[vertex]"` / `npm install @anthropic-ai/vertex-sdk`
- **Client**: `AnthropicVertex(project_id="...", region="us-east5")`
- **Claude Code**: Set `CLAUDE_CODE_USE_VERTEX=1`, `CLOUD_ML_REGION=global`, `ANTHROPIC_VERTEX_PROJECT_ID=...`
- **IAM**: `roles/aiplatform.user` with `aiplatform.endpoints.predict` permission
- **Features lag**: New features typically appear on direct API first, then Vertex weeks later
- **Files API**: Not available on Vertex AI

**Reference**: `references/google-vertex.md` — full Vertex AI guide with model IDs, SDK examples, authentication, regions, limitations, and Claude Code configuration.

### 5. SDKs (Python & TypeScript)

Write production integration code:

**Python** (`pip install anthropic`):
```python
from anthropic import Anthropic
client = Anthropic()  # uses ANTHROPIC_API_KEY env var

# Streaming
with client.messages.stream(
    model="claude-opus-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
```

**TypeScript** (`npm install @anthropic-ai/sdk`):
```typescript
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic();

const stream = client.messages.stream({
  model: "claude-opus-4-6",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello" }],
});
stream.on("text", (text) => console.log(text));
```

Both SDKs support: streaming, tool use, vision, extended thinking, prompt caching, async clients, Bedrock/Vertex backends, automatic retries, error handling.

**Reference**: `references/sdks.md` — complete SDK guide with Python and TypeScript examples for every feature, Bedrock/Vertex client setup, error handling, streaming patterns.

### 6. Claude Code CLI

Understand and configure the Claude Code development tool:

- **Installation**: `npm install -g @anthropic-ai/claude-code`
- **Modes**: Interactive, non-interactive (`--print`), plan mode
- **Permission modes**: default, allowedTools, bypassPermissions
- **Configuration hierarchy**: `~/.claude/settings.json` → `.claude/settings.json` → `.claude/settings.local.json`
- **CLAUDE.md**: Global (`~/.claude/CLAUDE.md`) and project-level instructions
- **Skills**: `SKILL.md` with frontmatter + references/ + assets/ + scripts/
- **Agent files**: `.claude/agents/*.md` — custom agent definitions
- **Slash commands**: `.claude/commands/*.md` — user-invocable commands
- **Hooks**: PreToolUse, PostToolUse, Notification, Stop, SubagentStop
- **MCP servers**: Configure in settings.json under `mcpServers`
- **Agent Teams**: TeamCreate, SendMessage, TaskCreate — multi-agent coordination
- **Model selection**: `/model sonnet`, `ANTHROPIC_MODEL=claude-opus-4-6`
- **Environment variables**: `ANTHROPIC_API_KEY`, `CLAUDE_CODE_USE_BEDROCK`, `CLAUDE_CODE_USE_VERTEX`, `ANTHROPIC_MODEL`, `ANTHROPIC_SMALL_FAST_MODEL`

**Reference**: `references/claude-code-cli.md` — full CLI guide with all configuration options, hooks, MCP setup, skills system, agent teams, and environment variables.

### 7. Prompt Engineering

Claude-specific prompt optimization patterns:

- **System prompts**: Set context, persona, constraints — loaded before user messages
- **XML tags**: Claude responds exceptionally well to `<tag>` structured prompts — use for separating instructions, context, examples
- **Extended thinking**: Enable for complex reasoning; set `budget_tokens` proportional to problem complexity
- **Prefill**: Pre-fill assistant response to steer output format (e.g., start with `{` for JSON)
- **Chain of thought**: "Think step-by-step" or structured `<thinking>` tags
- **Few-shot examples**: 2-5 examples in XML-tagged blocks
- **Structured output**: Use `output_config` with JSON Schema for guaranteed structure
- **Temperature**: 0.0 for deterministic/analytical, 0.5-0.7 for balanced, 1.0 for creative
- **Long context**: Claude handles 200K+ tokens well; put key instructions at start and end

**Reference**: `references/prompt-engineering.md` — comprehensive prompt engineering guide with Claude-specific patterns, anti-patterns, and optimization strategies.

## Behavior

### Deep Thinking

This skill does NOT give shallow answers. When asked a question like "should I use Bedrock or direct API?", it:

1. **Identifies the real decision factors**: latency requirements, data residency, existing cloud provider, feature needs, team expertise
2. **Walks through trade-offs**: Bedrock adds 10% regional premium but gives IAM/VPC integration. Direct API gets features first. Vertex AI if you're GCP-native.
3. **Recommends a path**: "Given X and Y, use Bedrock with global endpoints because..."
4. **Flags gotchas**: "But be aware that Files API isn't available on Bedrock/Vertex"

### Precision

- Uses exact model IDs, not approximations
- Provides real API shapes verified against official docs
- States when information may be outdated and suggests verification via web search
- Never hallucates endpoints or parameters

### Live Verification

When uncertain about current state (new model releases, pricing changes, API deprecations), the skill uses web search to verify against official documentation before answering.

## When to Use This Skill

Trigger this skill when:

- Configuring Claude on AWS Bedrock or Google Vertex AI
- Choosing which Claude model to use for a specific task
- Writing API integration code (Python, TypeScript, or direct HTTP)
- Setting up Claude Code CLI for a team or project
- Optimizing prompts for Claude specifically
- Understanding pricing, rate limits, or context window constraints
- Debugging API errors or SDK issues
- Comparing direct API vs Bedrock vs Vertex AI trade-offs
- Implementing streaming, tool use, extended thinking, or prompt caching
- Setting up MCP servers or creating Claude Code skills

## Anti-Patterns

- Using Haiku for tasks requiring deep reasoning (use Sonnet or Opus)
- Ignoring prompt caching for repetitive system prompts (wastes money)
- Using temperature 0 with extended thinking (must be 1)
- Hardcoding model IDs without version pinning strategy
- Using InvokeModel on Bedrock when Converse API works (Converse is the recommended API)
- Sending images without checking format support (JPEG, PNG, GIF, WebP only)
- Not handling `tool_use` stop_reason in agentic loops
- Ignoring the 5-minute cache TTL window for prompt caching

## Resources

### references/
- `anthropic-api.md` — Messages API, streaming, tool use, extended thinking, prompt caching, citations, batch API
- `aws-bedrock.md` — Model IDs, Converse API, SDK setup, global vs regional, Claude Code config
- `google-vertex.md` — Model IDs, SDK setup, authentication, regions, limitations
- `claude-code-cli.md` — CLI architecture, hooks, MCP, skills, agent teams, settings
- `model-selection.md` — Model comparison, pricing, decision framework, context windows
- `prompt-engineering.md` — Claude-specific patterns, XML tags, thinking, prefill, temperature
- `sdks.md` — Python and TypeScript SDK usage, Bedrock/Vertex clients, streaming, error handling
Comments 0
Latest | Hot
Please login before commenting.
No comments yet. Be the first one!
claude-deep-expert

Directory Structure

SKILL.md

Report

Notice
