Tools & Resources

I need a [language] [function/class] that:
- [requirement 1]
- [requirement 2]
- [requirement 3]

Please include:
- Error handling
- Documentation
- Type hints/annotations
- Unit tests

Please review the following code for:
- Code quality and best practices
- Potential bugs
- Performance issues
- Security vulnerabilities
- Documentation completeness

[Your code here]

I'm getting this error:
[error message]

In this code:
[code snippet]

Expected behavior: [description]
Actual behavior: [description]

Please help me:
1. Identify the root cause
2. Suggest a fix
3. Explain why it happened

Please generate comprehensive documentation for this code:
[code]

Include:
- Overview and purpose
- Parameters and return values
- Usage examples
- Edge cases and limitations

{
  "name": "API Integration",
  "steps": [
    {
      "task": "Design API endpoints",
      "prompt": "Design RESTful API endpoints for [feature]"
    },
    {
      "task": "Generate implementation",
      "prompt": "Implement the API using [framework]"
    },
    {
      "task": "Add tests",
      "prompt": "Generate integration tests"
    },
    {
      "task": "Documentation",
      "prompt": "Create API documentation"
    }
  ]
}

{
  "name": "Code Refactoring",
  "steps": [
    {
      "task": "Analysis",
      "prompt": "Analyze code for improvement opportunities"
    },
    {
      "task": "Plan",
      "prompt": "Create refactoring plan"
    },
    {
      "task": "Implement",
      "prompt": "Refactor code following the plan"
    },
    {
      "task": "Verify",
      "prompt": "Generate tests to verify behavior"
    }
  ]
}

import anthropic
 
def count_tokens(text: str, model: str = "claude-3-5-sonnet-20241022") -> int:
    """Estimate token count for text"""
    client = anthropic.Anthropic()
    return client.count_tokens(text)

import anthropic
from typing import List
 
async def batch_process(prompts: List[str]) -> List[str]:
    """Process multiple prompts in batch"""
    client = anthropic.Anthropic()
    results = []
 
    for prompt in prompts:
        message = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1024,
            messages=[{"role": "user", "content": prompt}]
        )
        results.append(message.content[0].text)
 
    return results

import anthropic
import hashlib
import json
from typing import Optional
 
class CachedClaude:
    def __init__(self):
        self.client = anthropic.Anthropic()
        self.cache = {}
 
    def _get_cache_key(self, prompt: str, model: str) -> str:
        data = f"{model}:{prompt}"
        return hashlib.md5(data.encode()).hexdigest()
 
    def query(self, prompt: str, model: str = "claude-3-5-sonnet-20241022") -> str:
        cache_key = self._get_cache_key(prompt, model)
 
        if cache_key in self.cache:
            return self.cache[cache_key]
 
        message = self.client.messages.create(
            model=model,
            max_tokens=1024,
            messages=[{"role": "user", "content": prompt}]
        )
 
        result = message.content[0].text
        self.cache[cache_key] = result
        return result

# Install
npm install -g @anthropic-ai/claude-cli
 
# Usage
claude "Write a Python function to sort a list"
 
# With file input
claude "Review this code" < script.py
 
# Stream output
claude --stream "Explain async/await in JavaScript"

from anthropic import Anthropic
 
class PromptTester:
    def __init__(self):
        self.client = Anthropic()
 
    def test_prompt(self, prompt: str, expected_keywords: list) -> bool:
        """Test if prompt generates expected content"""
        message = self.client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1024,
            messages=[{"role": "user", "content": prompt}]
        )
 
        response = message.content[0].text.lower()
        return all(keyword.lower() in response for keyword in expected_keywords)