Claude Practical Techniques [Part 2]

Building on the fundamental techniques from Part 1, this document focuses on production environment implementation, complex system design, and business strategies. Learn advanced implementation patterns essential for real-world work through specific code examples.

From multi-agent system design to production-grade API operations, custom MCP server development, and SaaS monetization pipeline construction—discover the knowledge needed to generate genuine business value using Claude.

Setup and context — Topics Covered in Part 2

This section deepens the foundational knowledge from Part 1, covering more complex implementation patterns required in actual production environments.

Goals for Part 2

Building Complex Systems: Architectural design for coordinating multiple agents rather than single agents
Production Operations Knowledge: Implementation patterns for scaling, error handling, and cost reduction
Extending Custom Features: Build custom MCP servers to implement project-specific tools
Business Monetization: Implementation and real-world examples of business models using Claude API

Multi-Agent System Design and Implementation

Efficiently handle complex tasks by distributing roles among multiple agents.

Orchestrator/Worker Configuration with Agent SDK

This pattern uses an orchestrator agent to control multiple worker agents and distribute tasks.

from anthropic import Anthropic
 
client = Anthropic()
 
# Worker agent: Content writing
def writer_agent(topic: str) -> str:
    """Write article on specified topic"""
 
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=2048,
        system="You are a professional technical writer. Write accurate and understandable articles.",
        messages=[
            {
                "role": "user",
                "content": f"Write a 1500-word technical article on: {topic}"
            }
        ]
    )
    return response.content[0].text
 
# Worker agent: Content review
def reviewer_agent(content: str) -> dict:
    """Review written content"""
 
    import json
 
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        system="You are an editor. Evaluate technical accuracy, writing quality, and structure.",
        messages=[
            {
                "role": "user",
                "content": f"""Review this article and return evaluation as JSON:
{{
  "score": 1-10,
  "issues": ["issue A", "issue B"],
  "suggestions": ["suggestion A", "suggestion B"]
}}
 
Article:
{content}"""
            }
        ]
    )
 
    return json.loads(response.content[0].text)
 
# Worker agent: Content improvement
def editor_agent(content: str, feedback: str) -> str:
    """Improve content based on feedback"""
 
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=2048,
        system="You are a professional editor. Improve the article based on feedback.",
        messages=[
            {
                "role": "user",
                "content": f"""Improve the article based on this feedback.
 
Feedback:
{feedback}
 
Original article:
{content}"""
            }
        ]
    )
    return response.content[0].text
 
# Orchestrator: Control overall flow
def orchestrator_agent(topic: str, max_iterations: int = 2) -> str:
    """Coordinate multiple agents to produce high-quality article"""
 
    print(f"▶ Topic: {topic}")
    print(f"▶ Max improvement loops: {max_iterations}")
 
    # Step 1: Write initial draft
    print("\n[Step 1] Writer agent creating initial draft...")
    content = writer_agent(topic)
 
    # Step 2-N: Review and improvement loop
    for iteration in range(max_iterations):
        print(f"\n[Step {iteration + 2}] Reviewer agent evaluating...")
        review = reviewer_agent(content)
 
        if review["score"] >= 8:
            print(f"✓ Score {review['score']}/10 - Goal achieved!")
            break
 
        print(f"✗ Score {review['score']}/10")
        print(f"   Issues: {', '.join(review['issues'][:2])}")
 
        print(f"\n[Step {iteration + 3}] Editor agent improving...")
        feedback = f"""
Issues: {', '.join(review['issues'])}
Suggestions: {', '.join(review['suggestions'])}
"""
        content = editor_agent(content, feedback)
 
    return content
 
# Execution example
final_article = orchestrator_agent("Claude API Cost Optimization")
print("\n" + "=" * 50)
print(final_article[:500] + "...")

Parallel Execution of Sub-Agents with Claude Code Task Tool

Use Claude Code's Task tool to run multiple independent tasks in parallel.

import asyncio
from anthropic import Anthropic
 
client = Anthropic()
 
async def parallel_data_processing():
    """Process multiple datasets in parallel"""
 
    # Datasets to process
    datasets = [
        {"id": 1, "name": "Sales Q1", "size": 50000},
        {"id": 2, "name": "Sales Q2", "size": 75000},
        {"id": 3, "name": "Sales Q3", "size": 60000},
    ]
 
    # Task to process each dataset
    async def process_dataset(dataset):
        print(f"▶ Processing {dataset['name']}...")
 
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=512,
            messages=[
                {
                    "role": "user",
                    "content": f"""
For dataset {dataset['name']} ({dataset['size']} rows),
provide analysis as JSON:
- estimated_revenue
- top_3_categories
- growth_rate
"""
                }
            ]
        )
 
        import json
        result = json.loads(response.content[0].text)
        result["dataset_id"] = dataset["id"]
 
        print(f"✓ {dataset['name']} processing complete")
        return result
 
    # Process all datasets in parallel
    tasks = [process_dataset(ds) for ds in datasets]
    results = await asyncio.gather(*tasks)
 
    # Aggregate results
    print("\n[Aggregated Results]")
    total_revenue = sum(r.get("estimated_revenue", 0) for r in results)
    print(f"Total Revenue: ${total_revenue:,}")
 
    return results
 
# Async execution (for actual use)
# results = asyncio.run(parallel_data_processing())

Error Recovery and Retry Strategies

In production, handling temporary failures is critical.

import time
from anthropic import APIError
 
def call_api_with_retry(
    messages: list,
    max_retries: int = 3,
    initial_wait: int = 1
) -> str:
    """API call with error handling and retry logic"""
 
    for attempt in range(max_retries):
        try:
            response = client.messages.create(
                model="claude-3-5-sonnet-20241022",
                max_tokens=1024,
                messages=messages
            )
            return response.content[0].text
 
        except APIError as e:
            if attempt < max_retries - 1:
                wait_time = initial_wait * (2 ** attempt)  # exponential backoff
                print(f"⚠ Error: {e.message}")
                print(f"  Retrying in {wait_time} seconds... (attempt {attempt + 1}/{max_retries})")
                time.sleep(wait_time)
            else:
                print(f"✗ Failed after {max_retries} attempts")
                raise
 
def call_api_with_fallback(messages: list, fallback_model: str = "claude-3-haiku-20250307") -> str:
    """Use fallback model if main model fails"""
 
    try:
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1024,
            messages=messages
        )
        return response.content[0].text
 
    except APIError:
        print(f"⚠ Main model unavailable. Using fallback model.")
 
        response = client.messages.create(
            model=fallback_model,
            max_tokens=512,
            messages=messages
        )
        return response.content[0].text

Production-Grade API Operations

Scaling, cost optimization, and reliability become critical in production.

Streaming with Concurrent Tool Use

Realize fast responses and tool integration simultaneously.

import Anthropic from "@anthropic-ai/sdk";
 
const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});
 
const tools = [
  {
    name: "get_weather",
    description: "Get weather for specified location",
    input_schema: {
      type: "object" as const,
      properties: {
        location: {
          type: "string",
          description: "Location name",
        },
      },
      required: ["location"],
    },
  },
  {
    name: "get_stock_price",
    description: "Get current stock price",
    input_schema: {
      type: "object" as const,
      properties: {
        symbol: {
          type: "string",
          description: "Ticker symbol (e.g., AAPL)",
        },
      },
      required: ["symbol"],
    },
  },
];
 
async function executeWithTools(userQuery: string): Promise<void> {
  console.log(`User: ${userQuery}\n`);
 
  let messages: Anthropic.Messages.MessageParam[] = [
    { role: "user", content: userQuery },
  ];
 
  // Tool use loop
  while (true) {
    const response = await client.messages.create({
      model: "claude-3-5-sonnet-20241022",
      max_tokens: 1024,
      tools: tools,
      messages: messages,
    });
 
    // Output streaming text
    for (const block of response.content) {
      if (block.type === "text") {
        process.stdout.write(block.text);
      }
    }
 
    // Check if tool use needed
    if (response.stop_reason !== "tool_use") {
      console.log("\n");
      break;
    }
 
    // Process tool calls
    const toolResults: Anthropic.Messages.ToolResultBlockParam[] = [];
 
    for (const block of response.content) {
      if (block.type === "tool_use") {
        console.log(`\n[Tool Execute] ${block.name}(${JSON.stringify(block.input)})`);
 
        // Simulate actual tool execution
        let result = "";
        if (block.name === "get_weather") {
          result = `${block.input.location} weather: Sunny, 25°C`;
        } else if (block.name === "get_stock_price") {
          result = `${block.input.symbol} current price: $150.25`;
        }
 
        toolResults.push({
          type: "tool_result",
          tool_use_id: block.id,
          content: result,
        });
      }
    }
 
    // Add tool results to messages
    messages.push({ role: "assistant", content: response.content });
    messages.push({
      role: "user",
      content: toolResults,
    });
  }
}
 
// Execution example
executeWithTools(
  "Tell me the weather in Tokyo and Apple's stock price"
);

Cost Optimization (Caching, Batch Processing, Model Selection)

Multiple techniques to reduce API costs.

from anthropic import Anthropic
 
client = Anthropic()
 
# Technique 1: Prompt caching
def cached_analysis(large_context: str, query: str) -> str:
    """Cache large context for reuse"""
 
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=512,
        system=[
            {
                "type": "text",
                "text": "You are an excellent analyst.",
            },
            {
                "type": "text",
                "text": f"Analyze this large reference material:\n{large_context}",
                "cache_control": {"type": "ephemeral"},  # Enable caching
            },
        ],
        messages=[{"role": "user", "content": query}],
    )
 
    return response.content[0].text
 
# Technique 2: Batch processing
def batch_processing(queries: list[str]) -> list[str]:
    """Efficiently process multiple queries"""
 
    results = []
 
    for query in queries:
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=256,
            messages=[{"role": "user", "content": query}],
        )
        results.append(response.content[0].text)
 
    return results
 
# Technique 3: Model selection optimization
def choose_optimal_model(task_complexity: str) -> str:
    """Select appropriate model by task complexity"""
 
    complexity_to_model = {
        "simple": "claude-3-haiku-20250307",  # Low cost
        "medium": "claude-3-5-sonnet-20241022",  # Balanced
        "complex": "claude-3-opus-20250219",  # Highest quality
    }
 
    return complexity_to_model.get(task_complexity, "claude-3-5-sonnet-20241022")
 
# Technique 4: Cost estimation
def estimate_api_cost(input_tokens: int, output_tokens: int, model: str) -> float:
    """Estimate API call cost"""
 
    pricing = {
        "claude-3-5-sonnet-20241022": {
            "input": 0.003,  # $3 per 1M input tokens
            "output": 0.015,  # $15 per 1M output tokens
        },
        "claude-3-opus-20250219": {
            "input": 0.015,
            "output": 0.075,
        },
        "claude-3-haiku-20250307": {
            "input": 0.00080,
            "output": 0.004,
        },
    }
 
    rates = pricing.get(model, pricing["claude-3-5-sonnet-20241022"])
 
    input_cost = (input_tokens / 1_000_000) * rates["input"]
    output_cost = (output_tokens / 1_000_000) * rates["output"]
 
    return input_cost + output_cost
 
# Usage example
print(f"Estimated cost: ${estimate_api_cost(5000, 1000, 'claude-3-5-sonnet-20241022'):.6f}")

Rate Limiting and Graceful Degradation

Patterns for handling API rate limits.

from anthropic import RateLimitError
import time
from datetime import datetime
 
class RateLimitManager:
    """Manage rate limiting"""
 
    def __init__(self, max_requests_per_minute: int = 60):
        self.max_requests = max_requests_per_minute
        self.request_timestamps = []
 
    def can_make_request(self) -> bool:
        """Check if request is currently possible"""
 
        now = datetime.now()
        # Remove requests older than 1 minute
        self.request_timestamps = [
            ts for ts in self.request_timestamps
            if (now - ts).seconds < 60
        ]
 
        return len(self.request_timestamps) < self.max_requests
 
    def wait_if_needed(self) -> None:
        """Wait if necessary"""
 
        while not self.can_make_request():
            sleep_time = 0.5
            print(f"⚠ Rate limit reached. Waiting {sleep_time} seconds...")
            time.sleep(sleep_time)
 
        self.request_timestamps.append(datetime.now())
 
def call_with_rate_limit_handling(
    messages: list,
    rate_limiter: RateLimitManager
) -> str:
    """API call with rate limit consideration"""
 
    rate_limiter.wait_if_needed()
 
    try:
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=512,
            messages=messages,
        )
        return response.content[0].text
 
    except RateLimitError:
        print("⚠ Rate limit error. Waiting 30 seconds before retry...")
        time.sleep(30)
 
        # Fallback: Use lower-speed model
        response = client.messages.create(
            model="claude-3-haiku-20250307",
            max_tokens=256,
            messages=messages,
        )
        return response.content[0].text

Building Custom MCP Servers

Create custom features for Claude by building your own MCP server.

Basic Server Structure (TypeScript)

import {
  StdioServerTransport,
  Server,
} from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  Tool,
  TextContent,
  CallToolRequest,
  CallToolRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
 
// Initialize MCP server
const server = new Server(
  {
    name: "custom-tools-server",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);
 
// Define tools
const tools: Tool[] = [
  {
    name: "analyze_csv",
    description: "Analyze CSV file and return statistics",
    inputSchema: {
      type: "object",
      properties: {
        filepath: {
          type: "string",
          description: "CSV file path",
        },
        operation: {
          type: "string",
          enum: ["summary", "describe", "correlate"],
          description: "Type of operation",
        },
      },
      required: ["filepath", "operation"],
    },
  },
  {
    name: "query_database",
    description: "Execute SQL query on database",
    inputSchema: {
      type: "object",
      properties: {
        query: {
          type: "string",
          description: "SQL query to execute",
        },
        limit: {
          type: "number",
          description: "Max rows to return",
        },
      },
      required: ["query"],
    },
  },
];
 
// Implement tools
async function handleToolCall(
  request: CallToolRequest
): Promise<TextContent> {
  const { name, arguments: args } = request;
 
  if (name === "analyze_csv") {
    const { filepath, operation } = args as {
      filepath: string;
      operation: string;
    };
 
    // CSV analysis logic
    let result = "";
 
    if (operation === "summary") {
      result = `Summary of ${filepath}: 1000 rows, 50 columns`;
    } else if (operation === "describe") {
      result = `Column info: id (int), name (string), score (float)`;
    }
 
    return {
      type: "text",
      text: result,
    };
  }
 
  if (name === "query_database") {
    const { query, limit = 10 } = args as {
      query: string;
      limit?: number;
    };
 
    // Database query logic
    const result = `Query executed: ${query} (max ${limit} rows)`;
 
    return {
      type: "text",
      text: result,
    };
  }
 
  throw new Error(`Unknown tool: ${name}`);
}
 
// Server setup
server.setRequestHandler(CallToolRequestSchema, handleToolCall);
 
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("MCP Server started");
}
 
main().catch(console.error);

Tool Definition and Validation (Zod)

Strict input validation pattern.

import { z } from "zod";
 
// Define validation with Zod schema
const AnalyzeCSVSchema = z.object({
  filepath: z
    .string()
    .min(1, "File path required")
    .regex(/\.csv$/, "Only CSV files supported"),
  operation: z.enum(["summary", "describe", "correlate"]),
  includeHeaders: z.boolean().optional().default(true),
});
 
type AnalyzeCSVInput = z.infer<typeof AnalyzeCSVSchema>;
 
// Handler with validation
function analyzeCSV(input: unknown): string {
  try {
    const validated: AnalyzeCSVInput = AnalyzeCSVSchema.parse(input);
 
    // Business logic here
    const { filepath, operation, includeHeaders } = validated;
 
    if (operation === "summary") {
      return `Display summary of ${filepath} (headers: ${includeHeaders})`;
    }
 
    return `Processing complete: ${operation}`;
  } catch (error) {
    if (error instanceof z.ZodError) {
      return `Validation error: ${error.errors[0].message}`;
    }
 
    throw error;
  }
}

Production Deployment Best Practices

# Dockerfile example
FROM node:20-alpine
 
WORKDIR /app
 
COPY package*.json ./
RUN npm ci --only=production
 
COPY src ./src
COPY dist ./dist
 
# Start MCP server in background
CMD ["node", "dist/server.js"]

#!/bin/bash
# Deployment script
 
# Build
npm run build
 
# Test
npm test
 
# Create Docker image
docker build -t mcp-server:latest .
 
# Push to production
docker push gcr.io/my-project/mcp-server:latest

Advanced Claude Code Customization

Advanced configuration to maximize Claude Code capabilities.

External Monitoring with HTTP Hooks

Notify external systems about Claude Code execution status.

{
  "hooks": {
    "http": {
      "onTaskStart": "https://monitoring.example.com/webhook/task-start",
      "onTaskComplete": "https://monitoring.example.com/webhook/task-complete",
      "onError": "https://monitoring.example.com/webhook/error"
    }
  }
}

# webhook.py - External monitoring system
from flask import Flask, request
 
app = Flask(__name__)
 
@app.route("/webhook/task-start", methods=["POST"])
def task_start():
    data = request.json
    print(f"▶ Task started: {data['taskId']}")
    return {"status": "received"}
 
@app.route("/webhook/task-complete", methods=["POST"])
def task_complete():
    data = request.json
    duration = data["duration"]
    print(f"✓ Task complete: {data['taskId']} ({duration}ms)")
    return {"status": "received"}
 
@app.route("/webhook/error", methods=["POST"])
def error_handler():
    data = request.json
    print(f"✗ Error: {data['message']}")
    # Send alert
    send_alert(f"Claude Code error: {data['message']}")
    return {"status": "received"}
 
if __name__ == "__main__":
    app.run(port=5000)

Custom Hooks (PreToolUse / PostToolUse)

Insert processing before and after tool execution.

# CLAUDE.md custom hook configuration
"""
## Custom Hooks
 
### PreToolUse Hook
Execution before tool running. API key validation, resource checking, etc.
 
### PostToolUse Hook
Execution after tool running. Result logging, cache updates, etc.
"""
 
# custom_hooks.py
import json
from datetime import datetime
 
class CustomHooks:
    @staticmethod
    def pre_tool_use(tool_name: str, arguments: dict) -> dict:
        """Processing before tool execution"""
 
        # Logging
        print(f"[{datetime.now().isoformat()}] Tool execution: {tool_name}")
        print(f"  Arguments: {json.dumps(arguments, indent=2)}")
 
        # API key validation
        if tool_name == "call_external_api":
            if "api_key" not in arguments:
                raise ValueError("api_key is required")
 
        # Resource checking
        if tool_name == "write_file":
            disk_usage = get_disk_usage()
            if disk_usage > 90:
                raise RuntimeError("Insufficient disk space")
 
        return arguments
 
    @staticmethod
    def post_tool_use(tool_name: str, result: str, execution_time: float) -> None:
        """Processing after tool execution"""
 
        # Execution time logging
        print(f"  Execution time: {execution_time:.2f}s")
 
        # Save to cache (speed up reuse of same tool)
        cache_key = f"{tool_name}:{hash(str(result))}"
        save_to_cache(cache_key, result)
 
        # Record metrics
        record_metric(f"tool.{tool_name}.execution_time", execution_time)
 
def get_disk_usage() -> float:
    """Get disk usage percentage"""
    import shutil
    total, used, free = shutil.disk_usage("/")
    return (used / total) * 100
 
def save_to_cache(key: str, value: str) -> None:
    """Save to cache"""
    pass
 
def record_metric(name: str, value: float) -> None:
    """Record metric"""
    pass

Git Workflow Automation

Automate code commits and branch management with Claude Code.

# git_automation.py
import subprocess
from datetime import datetime
 
class GitAutomation:
    @staticmethod
    def auto_commit(message: str = None) -> None:
        """Auto-commit changes"""
 
        # Check for changes
        status = subprocess.run(["git", "status", "--porcelain"], capture_output=True, text=True)
 
        if not status.stdout.strip():
            print("✓ No changes")
            return
 
        # Stage
        subprocess.run(["git", "add", "-A"])
 
        # Auto-generate commit message
        if not message:
            changed_files = status.stdout.strip().split("\n")[:3]
            message = f"Auto-commit: Update {len(changed_files)} files"
 
        subprocess.run(["git", "commit", "-m", message])
        print(f"✓ Committed: {message}")
 
    @staticmethod
    def create_feature_branch(feature_name: str) -> None:
        """Create feature branch"""
 
        branch_name = f"feature/{feature_name}-{datetime.now().strftime('%Y%m%d')}"
        subprocess.run(["git", "checkout", "-b", branch_name])
        print(f"✓ Branch created: {branch_name}")
 
    @staticmethod
    def auto_push() -> None:
        """Auto-push current branch"""
 
        subprocess.run(["git", "push", "-u", "origin", "HEAD"])
        print("✓ Push complete")
 
# Usage example
git = GitAutomation()
git.create_feature_branch("user-authentication")
# ... create code ...
git.auto_commit("Implement user authentication")
git.auto_push()

Building SaaS Monetization Pipelines

Three examples of implementing business models using Claude API.

Claude API × Stripe for Monthly Subscription Service

import stripe
from anthropic import Anthropic
 
stripe.api_key = "sk_live_..."
client = Anthropic()
 
# Stripe setup
PRODUCT_ID = "prod_..."
PRICE_ID = "price_..."
 
def create_subscription(customer_email: str) -> str:
    """Start monthly billing for customer"""
 
    # Create Stripe customer
    customer = stripe.Customer.create(email=customer_email)
 
    # Create subscription
    subscription = stripe.Subscription.create(
        customer=customer.id,
        items=[{"price": PRICE_ID}],
    )
 
    return subscription.id
 
def serve_premium_feature(user_id: str, query: str) -> str:
    """Provide advanced features to premium users"""
 
    # Check user subscription status
    subscription = get_user_subscription(user_id)
 
    if subscription and subscription.status == "active":
        # Use premium model
        model = "claude-3-opus-20250219"
        max_tokens = 4096
        premium_system = "You provide premium advanced analysis."
    else:
        # Use free model
        model = "claude-3-haiku-20250307"
        max_tokens = 512
        premium_system = "You provide basic support."
 
    response = client.messages.create(
        model=model,
        max_tokens=max_tokens,
        system=premium_system,
        messages=[{"role": "user", "content": query}],
    )
 
    return response.content[0].text
 
def get_user_subscription(user_id: str):
    """Get user subscription info"""
    # Database query
    pass

Kindle Publishing AI Automation Workflow

import os
from anthropic import Anthropic
 
client = Anthropic()
 
class KindlePublishingPipeline:
    def __init__(self, topic: str):
        self.topic = topic
        self.chapters = []
        self.cover_image = None
 
    def generate_outline(self) -> list:
        """Generate book structure"""
 
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=2048,
            messages=[
                {
                    "role": "user",
                    "content": f"""
Generate table of contents for technical book on {self.topic}.
Provide in format:
1. Prologue
2. Chapter 1: ...
3. Chapter 2: ...
...
 
Include detailed descriptions for each chapter.
"""
                }
            ]
        )
 
        outline_text = response.content[0].text
        self.outline = outline_text
        return outline_text
 
    def write_chapters(self) -> list:
        """Write each chapter"""
 
        chapters = []
 
        for chapter_num in range(1, 4):  # Generate 3 chapters
            print(f"✓ Writing chapter {chapter_num}...")
 
            response = client.messages.create(
                model="claude-3-5-sonnet-20241022",
                max_tokens=3000,
                messages=[
                    {
                        "role": "user",
                        "content": f"""
Write chapter {chapter_num} of {self.topic}.
 
Table of Contents:
{self.outline}
 
Requirements:
- 2000-3000 words
- Beginner-friendly explanation
- Real examples and code samples
- Markdown format for Kindle
"""
                    }
                ]
            )
 
            chapter_content = response.content[0].text
            chapters.append({
                "number": chapter_num,
                "content": chapter_content
            })
 
        self.chapters = chapters
        return chapters
 
    def generate_cover(self) -> str:
        """Generate cover image"""
 
        # Generate cover design description
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=512,
            messages=[
                {
                    "role": "user",
                    "content": f"""
Describe Kindle book cover design for {self.topic}.
Describe layout, colors, fonts, and image style in detail.
"""
                }
            ]
        )
 
        cover_description = response.content[0].text
 
        # External API (e.g., Midjourney) for image generation
        # image_url = call_image_generation_api(cover_description)
        image_url = "https://example.com/cover.jpg"
 
        return image_url
 
    def publish_to_kindle(self) -> bool:
        """Upload to Kindle Direct Publishing"""
 
        print(f"✓ Uploading '{self.topic}' to Kindle Direct Publishing...")
 
        # KDP API implementation
        # kdp_client.publish(
        #     title=f"{self.topic}: Complete Guide",
        #     content="\n\n".join([ch["content"] for ch in self.chapters]),
        #     cover_image=self.cover_image
        # )
 
        return True
 
# Usage example
pipeline = KindlePublishingPipeline("Web Scraping with Python")
pipeline.generate_outline()
pipeline.write_chapters()
pipeline.generate_cover()
pipeline.publish_to_kindle()
 
print("✓ Kindle publishing complete!")

YouTube Video Production Pipeline (Pollo AI + Suno AI)

from anthropic import Anthropic
 
client = Anthropic()
 
class YouTubeContentPipeline:
    def __init__(self, topic: str, duration_minutes: int = 10):
        self.topic = topic
        self.duration = duration_minutes
        self.script = None
        self.audio_url = None
        self.video_url = None
 
    def generate_script(self) -> str:
        """Generate YouTube video script"""
 
        word_count = self.duration * 130  # ~130 words per minute
 
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=3000,
            messages=[
                {
                    "role": "user",
                    "content": f"""
Generate {self.duration}-minute YouTube video script: "{self.topic}"
 
Requirements:
- Total words: ~{word_count}
- Conversational tone with natural flow
- Include [HH:MM] timecodes
- Include narration and B-roll instructions
 
Format:
[00:00 - Intro]
Content...
 
[00:30 - Main Section]
Content...
"""
                }
            ]
        )
 
        self.script = response.content[0].text
        return self.script
 
    def generate_audio(self) -> str:
        """Generate narration with Suno AI"""
 
        print("✓ Generating narration audio with Suno AI...")
 
        # Suno AI API (example)
        # audio_url = suno_client.generate_speech(
        #     text=self.script,
        #     voice="professional-narrator-en",
        #     duration_seconds=self.duration * 60
        # )
 
        self.audio_url = "https://example.com/narration.mp3"
        return self.audio_url
 
    def generate_visuals(self) -> str:
        """Generate visuals with Pollo AI"""
 
        print("✓ Generating visuals with Pollo AI...")
 
        # Extract scenes from script
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1024,
            messages=[
                {
                    "role": "user",
                    "content": f"""
Extract visual prompts for each scene from script.
Return as JSON: [time] → [visual prompt]
 
Script:
{self.script[:1000]}
"""
                }
            ]
        )
 
        visual_prompts = response.content[0].text
 
        # Pollo AI API (example)
        # video_url = pollo_client.generate_video(
        #     script=self.script,
        #     audio_url=self.audio_url,
        #     visual_prompts=visual_prompts
        # )
 
        self.video_url = "https://example.com/video.mp4"
        return self.video_url
 
    def publish_to_youtube(self, title: str, description: str) -> str:
        """Upload to YouTube"""
 
        print("✓ Uploading to YouTube...")
 
        # YouTube API
        # video_id = youtube_client.upload(
        #     video_url=self.video_url,
        #     title=title,
        #     description=description,
        #     tags=["AI", "Tutorial", self.topic]
        # )
 
        return "https://youtube.com/watch?v=dQw4w9WgXcQ"
 
# Usage example
pipeline = YouTubeContentPipeline("Claude API Practical Techniques", duration_minutes=15)
pipeline.generate_script()
pipeline.generate_audio()
pipeline.generate_visuals()
video_url = pipeline.publish_to_youtube(
    title="Building SaaS with Claude API",
    description="Practical guide to building monetizable SaaS applications using Claude API"
)
 
print(f"✓ Video published: {video_url}")

Summary — Related Premium Articles

Through advanced techniques in this document, you've learned production-level development technology with Claude.

Next Premium Article Series

"Multi-Agent System Design Pattern Collection"
"Production iOS/Android App Operations Techniques"
"Achieving Rapid SaaS Growth with AI Automation"
"Writing Kindle Bestsellers with Antigravity"

Join Claude Lab Premium to experience the forefront of AI-driven development.

Claude Practical Techniques [Part 2] — Production Operations, Multi-Agent & Monetization