Claude Code AI Assistant Cheat Sheet
Überblick
Claude Code ist ein von Anthropic entwickelter AI-powered Code-Assistent, der intelligente Code-Vervollständigung, Generation, Debugging und Erklärungsfähigkeiten bietet. Das auf Claudes fortgeschrittenem Sprachmodell aufgebaute Sprachmodell bietet kontextbezogene Programmierhilfen in mehreren Sprachen und Rahmen. Claude Code zeichnet sich durch das Verständnis komplexer Codebases aus, bietet detaillierte Erläuterungen und generiert qualitativ hochwertigen Code, der den besten Praktiken und Sicherheitsrichtlinien folgt.
ZEIT ** Nutzungshinweis**: Claude Code ist konzipiert, um Entwicklern zu helfen, sollte aber keine ordnungsgemäße Code-Review, Tests und Sicherheitspraktiken ersetzen. Immer validieren Sie AI-generierten Code vor der Produktion.
Erste Schritte
Web Interface Zugriff
# Access Claude Code via web interface
# Navigate to: https://claude.ai
# Sign up for an account or log in
# Select "Claude 3" model for code assistance
# Features available in web interface:
# - Code generation and completion
# - Code explanation and documentation
# - Debugging assistance
# - Architecture recommendations
# - Code review and optimization
```_
### API Integration
```python
# Install Anthropic Python SDK
pip install anthropic
# Basic API setup
import anthropic
client = anthropic.Anthropic(
api_key="your-api-key-here"
)
# Example code generation request
response = client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=1000,
messages=[
\\\\{
"role": "user",
"content": "Write a Python function to implement binary search"
\\\\}
]
)
print(response.content[0].text)
```_
### IDE Integration Setup
```bash
# VS Code Extension (unofficial community extensions)
# Search for "Claude" or "Anthropic" in VS Code marketplace
# Vim/Neovim integration
# Install via plugin manager (example with vim-plug)
Plug 'anthropic/claude.vim'
# Emacs integration
# Add to your .emacs or init.el
(require 'claude-mode)
# JetBrains IDEs
# Install Claude plugin from marketplace
# Configure API key in settings
```_
## Code Generation und Abschluss
### Basiscode Generation
```python
# Example prompts for code generation
# Function creation
prompt = """
Create a Python function that:
- Takes a list of dictionaries
- Filters by a specific key-value pair
- Returns sorted results by another key
- Includes error handling and type hints
"""
# Class implementation
prompt = """
Design a Python class for a REST API client that:
- Handles authentication
- Implements retry logic
- Supports async operations
- Includes comprehensive logging
"""
# Algorithm implementation
prompt = """
Implement a graph traversal algorithm that:
- Uses breadth-first search
- Finds shortest path between nodes
- Handles weighted edges
- Returns path and total cost
"""
```_
### Advanced Code Generation
```python
#!/usr/bin/env python3
# claude-code-generator.py
import anthropic
import json
import os
from typing import Dict, List, Optional
class ClaudeCodeGenerator:
def __init__(self, api_key: str):
self.client = anthropic.Anthropic(api_key=api_key)
self.conversation_history = []
def generate_code(self, prompt: str, language: str = "python",
context: Optional[str] = None) -> str:
"""Generate code based on prompt and context"""
system_prompt = f"""
You are an expert \\\\{language\\\\} developer. Generate clean, efficient,
and well-documented code that follows best practices. Include:
- Proper error handling
- Type hints (where applicable)
- Comprehensive docstrings
- Security considerations
- Performance optimizations
"""
if context:
full_prompt = f"Context:\n\\\\{context\\\\}\n\nRequest:\n\\\\{prompt\\\\}"
else:
full_prompt = prompt
try:
response = self.client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=2000,
system=system_prompt,
messages=[
\\\\{"role": "user", "content": full_prompt\\\\}
]
)
generated_code = response.content[0].text
# Store in conversation history
self.conversation_history.append(\\\\{
"prompt": prompt,
"language": language,
"response": generated_code,
"timestamp": datetime.now().isoformat()
\\\\})
return generated_code
except Exception as e:
return f"Error generating code: \\\\{e\\\\}"
def explain_code(self, code: str, language: str = "python") -> str:
"""Get detailed explanation of existing code"""
prompt = f"""
Analyze this \\\\{language\\\\} code and provide:
1. High-level overview of functionality
2. Line-by-line explanation of complex parts
3. Potential improvements or issues
4. Security considerations
5. Performance analysis
Code:
```{langument}
{code}
"""
try:
response = self.client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=1500,
messages=[
\\\\{"role": "user", "content": prompt\\\\}
]
)
return response.content[0].text
except Exception as e:
return f"Error explaining code: \\\\{e\\\\}"
def debug_code(self, code: str, error_message: str,
language: str = "python") -> str:
"""Debug code and suggest fixes"""
prompt = f"""
Debug this \\{language\\} code that's producing an error:
Error message: \\{error_message\\}
Code:
{code}
Please provide: 1. Root cause analysis 2. Specific fix recommendations 3. Corrected code 4. Prevention strategies for similar issues """
try:
response = self.client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=2000,
messages=[
\\\\{"role": "user", "content": prompt\\\\}
]
)
return response.content[0].text
except Exception as e:
return f"Error debugging code: \\\\{e\\\\}"
def optimize_code(self, code: str, language: str = "python") -> str:
"""Optimize code for performance and readability"""
prompt = f"""
Optimize this \\{language\\} code for: 1. Performance improvements 2. Memory efficiency 3. Code readability 4. Maintainability 5. Security best practices
Original code:
{code}
Provide optimized version with explanations of changes. """
try:
response = self.client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=2000,
messages=[
\\\\{"role": "user", "content": prompt\\\\}
]
)
return response.content[0].text
except Exception as e:
return f"Error optimizing code: \\\\{e\\\\}"
def generate_tests(self, code: str, language: str = "python") -> str:
"""Generate comprehensive test cases"""
framework_map = \\\\{
"python": "pytest",
"javascript": "jest",
"java": "junit",
"csharp": "nunit",
"go": "testing"
\\\\}
framework = framework_map.get(language, "appropriate testing framework")
prompt = f"""
Generate comprehensive test cases for this \\{language\\} code using \\{framework\\}:
Code to test:
{code}
Include: 1. Unit tests for all functions/methods 2. Edge cases and boundary conditions 3. Error handling tests 4. Integration tests (if applicable) 5. Performance tests (if relevant) 6. Mock objects where needed """
try:
response = self.client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=2000,
messages=[
\\\\{"role": "user", "content": prompt\\\\}
]
)
return response.content[0].text
except Exception as e:
return f"Error generating tests: \\\\{e\\\\}"
def save_conversation(self, filename: str = "claude_conversation.json"):
"""Save conversation history to file"""
try:
with open(filename, 'w') as f:
json.dump(self.conversation_history, f, indent=2)
print(f"Conversation saved to \\\\{filename\\\\}")
except Exception as e:
print(f"Error saving conversation: \\\\{e\\\\}")
Example usage
def main(): # Initialize with your API key api_key = os.getenv("ANTHROPIC_API_KEY") if not api_key: print("Please set ANTHROPIC_API_KEY environment variable") return
generator = ClaudeCodeGenerator(api_key)
# Generate a REST API client
prompt = """
Create a Python class for a REST API client that handles: - GET, POST, PUT, DELETE requests - Authentication with API keys - Retry logic with exponential backoff - Rate limiting - Response caching - Comprehensive error handling """
code = generator.generate_code(prompt, "python")
print("Generated Code:")
print("=" * 50)
print(code)
# Generate tests for the code
tests = generator.generate_tests(code, "python")
print("\nGenerated Tests:")
print("=" * 50)
print(tests)
# Save conversation
generator.save_conversation()
if name == "main": main()
## Mehrsprachige Unterstützung
### Python Entwicklung
```python
# Python-specific prompts and examples
# Data science and ML
prompt = """
Create a Python script for data analysis that:
- Loads data from CSV/JSON files
- Performs exploratory data analysis
- Creates visualizations with matplotlib/seaborn
- Implements basic ML models with scikit-learn
- Exports results and models
"""
# Web development with Flask/Django
prompt = """
Build a Flask web application that:
- Implements user authentication
- Uses SQLAlchemy for database operations
- Includes API endpoints with proper validation
- Implements middleware for logging and security
- Includes comprehensive error handling
"""
# DevOps and automation
prompt = """
Create a Python automation script that:
- Manages AWS resources using boto3
- Implements infrastructure as code
- Includes monitoring and alerting
- Handles secrets management
- Provides detailed logging and reporting
"""
```_
### JavaScript/TypScript-Entwicklung
```javascript
// JavaScript/TypeScript prompts
// React application development
const prompt = `
Create a React TypeScript component that:
- Implements a data table with sorting and filtering
- Uses React hooks for state management
- Includes proper TypeScript interfaces
- Implements accessibility features
- Includes comprehensive error boundaries
`;
// Node.js backend development
const prompt = `
Build a Node.js Express API that:
- Implements JWT authentication
- Uses TypeScript for type safety
- Includes input validation with Joi
- Implements rate limiting and security middleware
- Uses Prisma for database operations
`;
// Frontend optimization
const prompt = `
Optimize this JavaScript code for:
- Performance improvements
- Bundle size reduction
- Memory leak prevention
- Browser compatibility
- Accessibility compliance
`;
```_
### Entwicklung
```go
// Go-specific development prompts
// Microservices development
prompt := `
Create a Go microservice that:
- Implements gRPC and REST APIs
- Uses proper error handling patterns
- Includes comprehensive logging
- Implements health checks and metrics
- Uses dependency injection
`
// Concurrent programming
prompt := `
Implement a Go program that:
- Uses goroutines and channels effectively
- Implements worker pool pattern
- Handles graceful shutdown
- Includes proper synchronization
- Manages resource cleanup
`
```_
## Code Review und Analyse
### Automatisierte Code-Review
```python
#!/usr/bin/env python3
# claude-code-reviewer.py
import anthropic
import os
import subprocess
import json
from pathlib import Path
class ClaudeCodeReviewer:
def __init__(self, api_key: str):
self.client = anthropic.Anthropic(api_key=api_key)
def review_file(self, file_path: str) -> Dict:
"""Review a single code file"""
try:
with open(file_path, 'r', encoding='utf-8') as f:
code_content = f.read()
except Exception as e:
return \\\\{"error": f"Could not read file: \\\\{e\\\\}"\\\\}
file_extension = Path(file_path).suffix
language = self.detect_language(file_extension)
prompt = f"""
Perform a comprehensive code review of this \\\\{language\\\\} file:
File: \\\\{file_path\\\\}
```{langument}
{code_content}
Please analyze: 1. Code quality and best practices 2. Security vulnerabilities 3. Performance issues 4. Maintainability concerns 5. Documentation quality 6. Error handling 7. Testing coverage gaps 8. Specific improvement recommendations
Provide a structured review with severity levels (Critical, High, Medium, Low). """
try:
response = self.client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=2000,
messages=[
\\\\{"role": "user", "content": prompt\\\\}
]
)
return \\\\{
"file": file_path,
"language": language,
"review": response.content[0].text,
"status": "success"
\\\\}
except Exception as e:
return \\\\{
"file": file_path,
"error": f"Review failed: \\\\{e\\\\}",
"status": "error"
\\\\}
def review_directory(self, directory: str, extensions: List[str] = None) -> List[Dict]:
"""Review all code files in a directory"""
if extensions is None:
extensions = ['.py', '.js', '.ts', '.go', '.java', '.cpp', '.c', '.cs']
code_files = []
for ext in extensions:
code_files.extend(Path(directory).rglob(f"*\\\\{ext\\\\}"))
reviews = []
for file_path in code_files:
print(f"Reviewing: \\\\{file_path\\\\}")
review = self.review_file(str(file_path))
reviews.append(review)
return reviews
def review_git_diff(self, commit_range: str = "HEAD~1..HEAD") -> Dict:
"""Review changes in git diff"""
try:
# Get git diff
result = subprocess.run(
["git", "diff", commit_range],
capture_output=True,
text=True,
check=True
)
diff_content = result.stdout
if not diff_content.strip():
return \\\\{"message": "No changes found in the specified range"\\\\}
prompt = f"""
Review this git diff for: 1. Code quality issues 2. Security vulnerabilities 3. Breaking changes 4. Performance implications 5. Documentation updates needed 6. Testing requirements
Git diff:
{diff_content}
Focus on the changed lines and their impact on the codebase. """
response = self.client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=2000,
messages=[
\\\\{"role": "user", "content": prompt\\\\}
]
)
return \\\\{
"commit_range": commit_range,
"review": response.content[0].text,
"status": "success"
\\\\}
except subprocess.CalledProcessError as e:
return \\\\{
"error": f"Git command failed: \\\\{e\\\\}",
"status": "error"
\\\\}
except Exception as e:
return \\\\{
"error": f"Review failed: \\\\{e\\\\}",
"status": "error"
\\\\}
def detect_language(self, file_extension: str) -> str:
"""Detect programming language from file extension"""
language_map = \\\\{
'.py': 'python',
'.js': 'javascript',
'.ts': 'typescript',
'.go': 'go',
'.java': 'java',
'.cpp': 'cpp',
'.c': 'c',
'.cs': 'csharp',
'.rb': 'ruby',
'.php': 'php',
'.rs': 'rust',
'.kt': 'kotlin',
'.swift': 'swift'
\\\\}
return language_map.get(file_extension.lower(), 'unknown')
def generate_review_report(self, reviews: List[Dict], output_file: str = "code_review_report.md"):
"""Generate a comprehensive review report"""
report_lines = [
"# Code Review Report",
f"Generated on: \\\\{datetime.now().strftime('%Y-%m-%d %H:%M:%S')\\\\}",
"",
"## Summary",
""
]
# Count issues by severity
total_files = len([r for r in reviews if r.get('status') == 'success'])
error_files = len([r for r in reviews if r.get('status') == 'error'])
report_lines.extend([
f"- Total files reviewed: \\\\{total_files\\\\}",
f"- Files with errors: \\\\{error_files\\\\}",
"",
"## Detailed Reviews",
""
])
for review in reviews:
if review.get('status') == 'success':
report_lines.extend([
f"### \\\\{review['file']\\\\}",
f"**Language**: \\\\{review['language']\\\\}",
"",
review['review'],
"",
"---",
""
])
elif review.get('status') == 'error':
report_lines.extend([
f"### \\\\{review['file']\\\\} (ERROR)",
f"**Error**: \\\\{review['error']\\\\}",
"",
"---",
""
])
# Write report
try:
with open(output_file, 'w', encoding='utf-8') as f:
f.write('\n'.join(report_lines))
print(f"Review report saved to: \\\\{output_file\\\\}")
except Exception as e:
print(f"Error saving report: \\\\{e\\\\}")
def main(): import sys
api_key = os.getenv("ANTHROPIC_API_KEY")
if not api_key:
print("Please set ANTHROPIC_API_KEY environment variable")
return
reviewer = ClaudeCodeReviewer(api_key)
if len(sys.argv) < 2:
print("Usage:")
print(" python3 claude-code-reviewer.py <file_or_directory>")
print(" python3 claude-code-reviewer.py --git-diff [commit_range]")
return
if sys.argv[1] == "--git-diff":
commit_range = sys.argv[2] if len(sys.argv) > 2 else "HEAD~1..HEAD"
review = reviewer.review_git_diff(commit_range)
if review.get('status') == 'success':
print("Git Diff Review:")
print("=" * 50)
print(review['review'])
else:
print(f"Error: \\\\{review.get('error', 'Unknown error')\\\\}")
else:
target = sys.argv[1]
if os.path.isfile(target):
# Review single file
review = reviewer.review_file(target)
if review.get('status') == 'success':
print(f"Review for \\\\{target\\\\}:")
print("=" * 50)
print(review['review'])
else:
print(f"Error: \\\\{review.get('error', 'Unknown error')\\\\}")
elif os.path.isdir(target):
# Review directory
reviews = reviewer.review_directory(target)
reviewer.generate_review_report(reviews)
print(f"Reviewed \\\\{len(reviews)\\\\} files")
print("Detailed report saved to: code_review_report.md")
else:
print(f"Error: \\\\{target\\\\} is not a valid file or directory")
if name == "main": main()
## Architektur und Design Assistenz
### Systemarchitektur Design
```python
# Architecture design prompts
# Microservices architecture
prompt = """
Design a microservices architecture for an e-commerce platform that includes:
- User management service
- Product catalog service
- Order processing service
- Payment service
- Notification service
- API gateway configuration
- Database design for each service
- Inter-service communication patterns
- Security and authentication strategy
- Monitoring and logging approach
"""
# Database design
prompt = """
Design a database schema for a social media platform that supports:
- User profiles and relationships
- Posts, comments, and reactions
- Real-time messaging
- Content moderation
- Analytics and reporting
- Scalability considerations
- Data privacy compliance
"""
# API design
prompt = """
Design a RESTful API for a project management tool that includes:
- Resource endpoints and HTTP methods
- Request/response schemas
- Authentication and authorization
- Rate limiting strategy
- Error handling patterns
- API versioning approach
- Documentation structure
"""
```_
### Implementierung von Design Mustern
```python
#!/usr/bin/env python3
# claude-design-patterns.py
import anthropic
import os
class ClaudeDesignPatternAssistant:
def __init__(self, api_key: str):
self.client = anthropic.Anthropic(api_key=api_key)
def suggest_pattern(self, problem_description: str, language: str = "python") -> str:
"""Suggest appropriate design patterns for a problem"""
prompt = f"""
Analyze this software design problem and suggest appropriate design patterns:
Problem: \\\\{problem_description\\\\}
Target Language: \\\\{language\\\\}
Please provide:
1. Recommended design patterns with explanations
2. Implementation examples in \\\\{language\\\\}
3. Pros and cons of each pattern
4. Alternative approaches
5. Best practices for implementation
"""
try:
response = self.client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=2000,
messages=[
\\\\{"role": "user", "content": prompt\\\\}
]
)
return response.content[0].text
except Exception as e:
return f"Error getting pattern suggestions: \\\\{e\\\\}"
def implement_pattern(self, pattern_name: str, context: str, language: str = "python") -> str:
"""Generate implementation of a specific design pattern"""
prompt = f"""
Implement the \\\\{pattern_name\\\\} design pattern in \\\\{language\\\\} for this context:
Context: \\\\{context\\\\}
Please provide:
1. Complete implementation with proper class structure
2. Usage examples
3. Unit tests
4. Documentation and comments
5. Common pitfalls to avoid
"""
try:
response = self.client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=2000,
messages=[
\\\\{"role": "user", "content": prompt\\\\}
]
)
return response.content[0].text
except Exception as e:
return f"Error implementing pattern: \\\\{e\\\\}"
def refactor_with_patterns(self, code: str, language: str = "python") -> str:
"""Suggest refactoring existing code using design patterns"""
prompt = f"""
Analyze this \\\\{language\\\\} code and suggest refactoring using appropriate design patterns:
Current code:
```{langument}
{code}
Please provide: 1. Identified code smells and issues 2. Recommended design patterns for improvement 3. Refactored code implementation 4. Explanation of improvements 5. Migration strategy from old to new code """
try:
response = self.client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=2000,
messages=[
\\\\{"role": "user", "content": prompt\\\\}
]
)
return response.content[0].text
except Exception as e:
return f"Error refactoring code: \\\\{e\\\\}"
Example usage
def main(): api_key = os.getenv("ANTHROPIC_API_KEY") if not api_key: print("Please set ANTHROPIC_API_KEY environment variable") return
assistant = ClaudeDesignPatternAssistant(api_key)
# Example: Suggest patterns for a logging system
problem = """
I need to design a logging system that: - Supports multiple output destinations (file, console, database) - Allows different log levels (DEBUG, INFO, WARN, ERROR) - Can be configured at runtime - Supports custom formatting - Is thread-safe and performant """
suggestions = assistant.suggest_pattern(problem, "python")
print("Design Pattern Suggestions:")
print("=" * 50)
print(suggestions)
if name == "main": main() ```_
Integration und Automatisierung
CI/CD Integration
```yaml
GitHub Actions workflow for Claude Code integration
name: Claude Code Review
on: pull_request: branches: [ main, develop ]
jobs: claude-review: runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
with:
fetch-depth: 0
- name: Set up Python
uses: actions/setup-python@v4
with:
python-version: '3.9'
- name: Install dependencies
run: |
pip install anthropic
- name: Run Claude Code Review
env:
ANTHROPIC_API_KEY: $\\\\{\\\\{ secrets.ANTHROPIC_API_KEY \\\\}\\\\}
run: |
python3 .github/scripts/claude-review.py
- name: Comment PR
uses: actions/github-script@v6
with:
script: |
const fs = require('fs');
const review = fs.readFileSync('claude-review-output.md', 'utf8');
github.rest.issues.createComment(\\\\{
issue_number: context.issue.number,
owner: context.repo.owner,
repo: context.repo.repo,
body: `## Claude Code Review\n\n$\\{review\\}`
\\\\});
```_
VS Code Erweiterung Integration
json
// VS Code settings for Claude integration
\\\\{
"claude.apiKey": "$\\\\{env:ANTHROPIC_API_KEY\\\\}",
"claude.model": "claude-3-sonnet-20240229",
"claude.maxTokens": 1000,
"claude.autoComplete": true,
"claude.codeReview": true,
"claude.explainCode": true,
"claude.generateTests": true,
"claude.languages": [
"python",
"javascript",
"typescript",
"go",
"java",
"cpp"
]
\\\\}_
Kommandozeilen-Tool
```bash
!/bin/bash
claude-cli.sh - Command line interface for Claude Code
CLAUDE_API_KEY="$\\{ANTHROPIC_API_KEY\\}" CLAUDE_MODEL="claude-3-sonnet-20240229"
if [ -z "$CLAUDE_API_KEY" ]; then echo "Error: ANTHROPIC_API_KEY environment variable not set" exit 1 fi
case "$1" in
"generate")
if [ -z "$2" ]; then
echo "Usage: claude-cli.sh generate
"explain")
if [ -z "$2" ]; then
echo "Usage: claude-cli.sh explain <file>"
exit 1
fi
if [ ! -f "$2" ]; then
echo "Error: File $2 not found"
exit 1
fi
code_content=$(cat "$2")
python3 -c "
import anthropic client = anthropic.Anthropic(api_key='$CLAUDE_API_KEY') response = client.messages.create( model='$CLAUDE_MODEL', max_tokens=1500, messages=[\\{ 'role': 'user', 'content': 'Explain this code:\n\n$code_content' \\}] ) print(response.content[0].text) " ;;
"review")
if [ -z "$2" ]; then
echo "Usage: claude-cli.sh review <file>"
exit 1
fi
python3 claude-code-reviewer.py "$2"
;;
"test")
if [ -z "$2" ]; then
echo "Usage: claude-cli.sh test <file>"
exit 1
fi
code_content=$(cat "$2")
python3 -c "
import anthropic client = anthropic.Anthropic(api_key='$CLAUDE_API_KEY') response = client.messages.create( model='$CLAUDE_MODEL', max_tokens=2000, messages=[\\{ 'role': 'user', 'content': 'Generate comprehensive test cases for this code:\n\n$code_content' \\}] ) print(response.content[0].text) " ;;
*)
echo "Claude Code CLI Tool"
echo "Usage:"
echo " claude-cli.sh generate <prompt> - Generate code from prompt"
echo " claude-cli.sh explain <file> - Explain code in file"
echo " claude-cli.sh review <file> - Review code in file"
echo " claude-cli.sh test <file> - Generate tests for code"
echo ""
echo "Environment variables:"
echo " ANTHROPIC_API_KEY - Your Anthropic API key"
;;
esac ```_
Best Practices und Tipps
Effektive Vermutung
```python
Best practices for Claude Code prompts
Be specific about requirements
good_prompt = """ Create a Python function that: - Validates email addresses using regex - Returns True for valid emails, False for invalid - Handles edge cases (empty strings, None values) - Includes comprehensive docstring - Uses type hints - Includes at least 3 test cases """
Provide context and constraints
contextual_prompt = """ I'm building a web scraping application. Create a Python class that: - Uses requests and BeautifulSoup - Implements rate limiting (max 1 request per second) - Handles HTTP errors gracefully - Supports custom headers and user agents - Includes retry logic with exponential backoff - Logs all activities - Respects robots.txt
The class will be used to scrape product information from e-commerce sites. """
Ask for explanations and alternatives
comprehensive_prompt = """ Implement a caching mechanism in Python that: - Supports both in-memory and Redis backends - Implements LRU eviction policy - Includes TTL (time-to-live) support - Is thread-safe - Provides async/await support
Please also explain: - When to use each backend - Performance considerations - Alternative caching strategies - Potential pitfalls and how to avoid them """ ```_
Richtlinien für die Qualität der Produkte
```python
Guidelines for working with Claude-generated code
def validate_generated_code(code: str) -> List[str]: """Validate Claude-generated code for common issues"""
issues = []
# Check for security issues
security_patterns = [
'eval(',
'exec(',
'os.system(',
'subprocess.call(',
'input(', # In production code
'raw_input('
]
for pattern in security_patterns:
if pattern in code:
issues.append(f"Potential security issue: \\\\{pattern\\\\}")
# Check for best practices
if 'import *' in code:
issues.append("Avoid wildcard imports")
if 'except:' in code and 'except Exception:' not in code:
issues.append("Use specific exception handling")
# Check for documentation
if 'def ' in code and '"""' not in code:
issues.append("Missing docstrings for functions")
return issues
def review_checklist(): """Checklist for reviewing Claude-generated code"""
checklist = [
"□ Code follows language-specific style guidelines",
"□ Proper error handling implemented",
"□ Security considerations addressed",
"□ Performance implications considered",
"□ Code is testable and maintainable",
"□ Documentation is comprehensive",
"□ Dependencies are appropriate",
"□ Edge cases are handled",
"□ Code is compatible with target environment",
"□ No hardcoded secrets or credentials"
]
return checklist
```_
Leistungsoptimierung
```python
Tips for optimizing Claude Code usage
class ClaudeOptimizer: def init(self): self.cache = \\{\\} self.conversation_context = []
def optimize_prompt_length(self, prompt: str, max_length: int = 4000) -> str:
"""Optimize prompt length for better performance"""
if len(prompt) <= max_length:
return prompt
# Prioritize important sections
sections = prompt.split('\n\n')
essential_sections = []
optional_sections = []
for section in sections:
if any(keyword in section.lower() for keyword in
['requirements', 'must', 'should', 'error', 'security']):
essential_sections.append(section)
else:
optional_sections.append(section)
# Build optimized prompt
optimized = '\n\n'.join(essential_sections)
# Add optional sections if space allows
for section in optional_sections:
if len(optimized) + len(section) + 2 <= max_length:
optimized += '\n\n' + section
else:
break
return optimized
def batch_requests(self, prompts: List[str]) -> List[str]:
"""Batch multiple requests for efficiency"""
# Combine related prompts
combined_prompt = "Please address the following requests:\n\n"
for i, prompt in enumerate(prompts, 1):
combined_prompt += f"\\\\{i\\\\}. \\\\{prompt\\\\}\n\n"
combined_prompt += "Please provide numbered responses for each request."
return [combined_prompt]
def use_conversation_context(self, new_prompt: str) -> str:
"""Leverage conversation context for better results"""
if not self.conversation_context:
return new_prompt
context_summary = "Previous context:\n"
for item in self.conversation_context[-3:]: # Last 3 interactions
context_summary += f"- \\\\{item\\\\}\n"
return f"\\\\{context_summary\\\\}\nCurrent request:\n\\\\{new_prompt\\\\}"
```_
Fehlerbehebung
Gemeinsame Themen und Lösungen
```python
Common issues when using Claude Code
def troubleshoot_api_issues(): """Common API issues and solutions"""
issues = \\\\{
"Rate limiting": \\\\{
"symptoms": ["429 status code", "Rate limit exceeded"],
"solutions": [
"Implement exponential backoff",
"Reduce request frequency",
"Use batch requests when possible",
"Check your usage limits"
]
\\\\},
"Token limits": \\\\{
"symptoms": ["Response truncated", "Max tokens reached"],
"solutions": [
"Reduce prompt length",
"Split complex requests",
"Increase max_tokens parameter",
"Use conversation context efficiently"
]
\\\\},
"Authentication errors": \\\\{
"symptoms": ["401 status code", "Invalid API key"],
"solutions": [
"Verify API key is correct",
"Check environment variable",
"Ensure API key has proper permissions",
"Regenerate API key if needed"
]
\\\\},
"Poor code quality": \\\\{
"symptoms": ["Buggy code", "Security issues", "Poor performance"],
"solutions": [
"Improve prompt specificity",
"Provide better context",
"Ask for explanations",
"Request multiple alternatives",
"Always review and test generated code"
]
\\\\}
\\\\}
return issues
def debug_generated_code(code: str, error_message: str = None): """Debug issues with generated code"""
debug_steps = [
"1. Read the code carefully and understand its purpose",
"2. Check for syntax errors and typos",
"3. Verify all imports and dependencies",
"4. Test with simple inputs first",
"5. Add logging and debug prints",
"6. Check error messages and stack traces",
"7. Validate input parameters and types",
"8. Review error handling logic",
"9. Test edge cases and boundary conditions",
"10. Ask Claude to explain or debug the code"
]
if error_message:
print(f"Error: \\\\{error_message\\\\}")
print("Debug steps:")
for step in debug_steps:
print(f" \\\\{step\\\\}")
```_
Ressourcen und Dokumentation
Offizielle Mittel
- Anthropische Claude Dokumentation
- [Claude API Reference](_LINK_12___ -%20Anthropische%20Python%20SDK
- [Richtlinien für die Sicherheit](_LINK_12___
%20Gemeinschaftsmittel
-%20[Claude%20Developer%20Community](LINK_12 -%20[Claude%20Code%20Beispiele](_LINK_12 -%20(__LINK_12) - (_LINK_12_)
Integrationsbeispiele
- [VS Code Extension Development](__LINK_12___ -%20GitHub%20Aktionsintegration
- [CI/CD Pipeline Beispiele](__LINK_12___ -%20API%20Integration%20Patterns
--
*Dieses Betrugsblatt bietet umfassende Anleitung für die Verwendung von Claude Code als AI-powered Development Assistant. Überprüfen und testen Sie AI-generierten Code vor der Produktion und folgen Sie den besten Sicherheitspraktiken für API-Schlüsselmanagement. *