Build apps with the Claude API or Anthropic SDK. TRIGGER when: code imports `anthropic`/`@anthropic-ai/sdk`/`claude_agent_sdk`, or user asks to use Claude API, Anthropic SDKs, or Agent SDK. DO NOT TRIGGER when: code imports `openai`/other AI SDK, general programming, or ML/data-science tasks.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
Build apps with the Claude API or Anthropic SDK. TRIGGER when: code imports `anthropic`/`@anthropic-ai/sdk`/`claude_agent_sdk`, or user asks to use Claude API, Anthropic SDKs, or Agent SDK. DO NOT TRIGGER when: code imports `openai`/other AI SDK, general programming, or ML/data-science tasks.
["Use claude-opus-4-6 as default model unless user specifies otherwise","Use thinking with type adaptive not budget_tokens (deprecated)","Use streaming for requests with long input, output, or high max_tokens","Use get_final_message or finalMessage helper for complete streamed responses","Use parse tool inputs with proper JSON methods not string operations","Never truncate user inputs — discuss options instead"]
error_handling
strict
streaming
supported
source
builtin
trust_score
100
provenance_sha
13eb18938323db2e
Claude API & Agent SDK
Defaults
Model: claude-opus-4-6 (unless user specifies otherwise)
Streaming: Default for large inputs, large outputs, or high max_tokens
Streaming completion: Use .get_final_message() (Python) / .finalMessage() (TypeScript)
Language Detection
Infer language from project files. Support: Python, TypeScript/JavaScript, Java/Kotlin/Scala, Go, Ruby, C#, PHP, cURL. If multiple languages detected, clarify which is relevant.
Which Surface to Use
Use Case
Surface
Single LLM call (classify, summarize, extract, Q&A)
Claude API direct
Multi-step pipelines with tool use
Claude API + tool use
Open-ended autonomous agents
Claude API agentic loop or Agent SDK
Built-in tools (files, web, terminal)
Agent SDK
Current Models
Model
ID
Context
Input $/1M
Output $/1M
Claude Opus 4.6
claude-opus-4-6
200K (1M beta)
$5.00
$25.00
Claude Sonnet 4.6
claude-sonnet-4-6
200K (1M beta)
$3.00
$15.00
Claude Haiku 4.5
claude-haiku-4-5
200K
$1.00
$5.00
Default to claude-opus-4-6 unless the user explicitly requests another model.
Use streaming when max_tokens is large or inputs are long:
Python
with client.messages.stream(
model="claude-opus-4-6",
max_tokens=4096,
messages=[{"role": "user", "content": prompt}]
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
# For complete response with metadata:
final = stream.get_final_message()
Determines which feature to work on next (marks completed ones)
Prepares context and constraints for the coding agent
Spawns the coding agent with focused instructions
Coding Agent
Receives a single focused task from the initializer
Implements using TDD (write tests, implement, verify)
Commits progress to git after each logical unit
Reports completion back to the initializer
Git-Persisted Progress
The key innovation: progress is persisted via git commits, not in-memory state.
from claude_agent_sdk import Agent, tool
@tooldefcommit_progress(message: str, files: list[str]):
"""Commit completed work to git."""
subprocess.run(["git", "add"] + files, check=True)
subprocess.run(["git", "commit", "-m", message], check=True)
Between sessions:
Git log shows what was completed
Feature list file shows what remains
No session state needed — fresh agent reads git history
Feature List Tracking
Maintain a features.md file that both agents read/write:
# Features- [x] User authentication (JWT)
- [x] Database schema setup
- [ ] API endpoints for CRUD <-- next
- [ ] Frontend dashboard
- [ ] Email notifications
The initializer marks features complete after the coding agent finishes each one.
When to Use This Pattern
Building complete applications over multiple sessions
Long-running projects that exceed single context windows
Projects requiring incremental, testable progress
Autonomous coding with minimal human intervention
Support Agent Quickstart Pattern
Build a customer support agent that handles tickets, escalates unresolved issues, and maintains conversation history (from anthropics/claude-quickstarts):
import anthropic
from typing importOptional
client = anthropic.Anthropic()
SUPPORT_SYSTEM_PROMPT = """You are a helpful customer support agent for Acme Corp.
You have access to the following tools to help customers:
- look_up_order: Find order status by order ID
- process_refund: Initiate a refund for an order
- escalate_ticket: Escalate to human support with a reason
Always be polite and empathetic. If you cannot resolve an issue, escalate it."""
support_tools = [
{
"name": "look_up_order",
"description": "Look up the status of a customer order",
"input_schema": {
"type": "object",
"properties": {
"order_id": {"type": "string", "description": "The order ID (e.g. ORD-12345)"}
},
"required": ["order_id"]
}
},
{
"name": "process_refund",
"description": "Process a refund for a completed order",
"input_schema": {
"type": "object",
"properties": {
"order_id": {"type": "string"},
"reason": {"type": "string", "description": "Reason for refund"}
},
"required": ["order_id", "reason"]
}
},
{
"name": "escalate_ticket",
"description": "Escalate an unresolved issue to human support",
"input_schema": {
"type": "object",
"properties": {
"issue_summary": {"type": "string"},
"priority": {"type": "string", "enum": ["low", "medium", "high"]}
},
"required": ["issue_summary", "priority"]
}
}
]
defrun_support_agent(user_message: str, conversation_history: list) -> tuple[str, list]:
"""Run one turn of the support agent, returning (response, updated_history)."""
conversation_history.append({"role": "user", "content": user_message})
whileTrue:
response = client.messages.create(
model="claude-opus-4-6",
max_tokens=2048,
system=SUPPORT_SYSTEM_PROMPT,
tools=support_tools,
messages=conversation_history
)
if response.stop_reason == "end_turn":
text_content = next((b.text for b in response.content ifhasattr(b, 'text')), "")
conversation_history.append({"role": "assistant", "content": response.content})
return text_content, conversation_history
# Handle tool use
tool_results = []
for block in response.content:
if block.type == "tool_use":
result = execute_tool(block.name, block.input)
tool_results.append({
"type": "tool_result",
"tool_use_id": block.id,
"content": str(result)
})
conversation_history.append({"role": "assistant", "content": response.content})
conversation_history.append({"role": "user", "content": tool_results})
Financial Analyst Agent Pattern
Build a financial analysis agent that processes market data and generates reports (from anthropics/claude-quickstarts):
import anthropic
import json
client = anthropic.Anthropic()
financial_tools = [
{
"name": "get_stock_price",
"description": "Get current and historical stock price data",
"input_schema": {
"type": "object",
"properties": {
"symbol": {"type": "string", "description": "Stock ticker symbol (e.g. AAPL)"},
"period": {"type": "string", "enum": ["1d", "1w", "1m", "3m", "1y"],
"description": "Time period for historical data"}
},
"required": ["symbol"]
}
},
{
"name": "calculate_metrics",
"description": "Calculate financial metrics like PE ratio, moving averages, volatility",
"input_schema": {
"type": "object",
"properties": {
"symbol": {"type": "string"},
"metrics": {
"type": "array",
"items": {"type": "string", "enum": ["pe_ratio", "ma_50", "ma_200", "volatility", "beta"]},
"description": "Financial metrics to calculate"
}
},
"required": ["symbol", "metrics"]
}
},
{
"name": "generate_report",
"description": "Generate a structured financial analysis report",
"input_schema": {
"type": "object",
"properties": {
"symbol": {"type": "string"},
"report_type": {"type": "string", "enum": ["summary", "detailed", "comparison"]},
"output_format": {"type": "string", "enum": ["markdown", "json", "html"]}
},
"required": ["symbol", "report_type"]
}
}
]
FINANCIAL_SYSTEM_PROMPT = """You are an expert financial analyst. Analyze stocks and market data
to provide actionable insights. Always:
1. Gather relevant data before making recommendations
2. Consider multiple metrics and timeframes
3. Clearly state assumptions and limitations
4. Structure analysis with: Summary → Data Analysis → Key Findings → Recommendation"""defanalyze_stock(symbol: str, question: Optional[str] = None) -> str:
"""Run a financial analysis agent for a given stock symbol."""
prompt = question orf"Provide a comprehensive analysis of {symbol} stock."
messages = [{"role": "user", "content": prompt}]
whileTrue:
response = client.messages.create(
model="claude-opus-4-6",
max_tokens=4096,
system=FINANCIAL_SYSTEM_PROMPT,
tools=financial_tools,
messages=messages
)
if response.stop_reason == "end_turn":
returnnext((b.text for b in response.content ifhasattr(b, 'text')), "")
tool_results = []
for block in response.content:
if block.type == "tool_use":
result = execute_financial_tool(block.name, block.input)
tool_results.append({
"type": "tool_result",
"tool_use_id": block.id,
"content": json.dumps(result)
})
messages.append({"role": "assistant", "content": response.content})
messages.append({"role": "user", "content": tool_results})
Common Pitfalls
Pitfall
Fix
Using budget_tokens in thinking
Use thinking: {type: "adaptive"} instead
Truncating long inputs
Discuss chunking or summarization options with user
Using output_format
Use output_config: {format: {...}} instead
Not streaming large responses
Add streaming for max_tokens > 4096
String manipulation on tool inputs
Use json.loads(block.input) / JSON.parse(block.input)
