AI Code Generation: Developer Productivity Tools in 2025

# AI coding tool comparison
tools:
  - name: "GitHub Copilot"
    type: "IDE Extension"
    models: "GPT-4, Claude"
    context: "Current file, imports"
    best_for: "General purpose coding"
    privacy: "Code sent to Microsoft"
    price: "$10/month"
    
  - name: "Cursor"
    type: "AI-first IDE"
    models: "GPT-4, Claude"
    context: "Full project"
    best_for: "Complex refactoring, new features"
    privacy: "Data processed by OpenAI/Anthropic"
    price: "$20/month (Pro)"
    
  - name: "Claude Code"
    type: "CLI Assistant"
    models: "Claude 3.5"
    context: "Full codebase"
    best_for: "Terminal workflows, debugging"
    privacy: "Enterprise options available"
    price: "$20/month"
    
  - name: "Aider"
    type: "Terminal Tool"
    models: "GPT-4, Claude"
    context: "Git repo"
    best_for: "TUI enthusiasts, automation"
    privacy: "Local processing option"
    price: "Free/Open Source"
    
  - name: "Tabnine"
    type: "IDE Extension"
    models: "Own + GPT"
    context: "Local + cloud"
    best_for: "Privacy-sensitive projects"
    privacy: "Local execution available"
    price: "$12/month"

# .copilotignore - Exclude files from context
exclude:
  - "**/*.min.js"
  - "**/node_modules/**"
  - "**/dist/**"
  - "**/build/**"
  - "**/*.env*"
  - "**/secrets/**"
  - "**/credentials/**"
  - "**/*.log"

// copilot-config - Configure Copilot behavior
{
  "github.copilot.advanced": {
    "keepDefaultAutocomplete": true,
    "inlineSuggestEnabled": true,
    "secretStorage": "desktop",
    "enableAutoCompletions": true,
    "promptToRefactor": {
      "enabled": true,
      "languages": ["javascript", "typescript", "python"]
    }
  }
}

# Good Copilot prompts (will get better results)

# ❌ Bad: Too vague
def process():
    pass

# ✅ Good: Clear intent and context
def process_user_order(order_id: str, user_id: str) -> OrderResult:
    """
    Process a user order and initiate fulfillment.
    
    Args:
        order_id: Unique order identifier
        user_id: Customer's user ID
        
    Returns:
        OrderResult with status and tracking info
        
    Raises:
        OrderNotFoundError: If order doesn't exist
        InventoryError: If items out of stock
    """
    # Implementation...


# ❌ Bad: No type hints or documentation
def calc(x, y):
    return x * y + (x / y)

# ✅ Good: Types, validation, error handling
def calculate_discount(
    original_price: Decimal,
    discount_percent: float,
    member_tier: Literal["bronze", "silver", "gold"]
) -> Decimal:
    """
    Calculate final price after discount and tier bonus.
    
    Bronze: base discount
    Silver: base + 5%
    Gold: base + 10%
    """
    if not 0 <= discount_percent <= 100:
        raise ValueError("Discount must be 0-100")
    
    discount = original_price * Decimal(discount_percent / 100)
    
    tier_bonus = {
        "bronze": Decimal("0"),
        "silver": Decimal("0.05"),
        "gold": Decimal("0.10")
    }[member_tier]
    
    final_discount = discount + (original_price * tier_bonus)
    return (original_price - final_discount).quantize(Decimal("0.01"))

# Cursor-specific features

# @Symbol References - Find all usages
def process_payment(amount: float, currency: str) -> Receipt:
    """Process payment with currency conversion"""
    # Use @process_payment to find all calls
    
# @Files - Include multiple files in context
def generate_report():
    """
    Include @database.ts, @models/user.ts, @utils/format.ts
    Generate a comprehensive sales report
    """
    pass

# @Web - Search the web for solutions
# When stuck, use @Web to search for solutions

# Useful Cursor keyboard shortcuts
shortcuts:
  - keys: "Ctrl+K / Cmd+K"
    action: "Generate code / Edit selection"
    
  - keys: "Ctrl+L / Cmd+L"
    action: "Chat with AI about current file"
    
  - keys: "Ctrl+Shift+R"
    action: "Refactor with AI assistance"
    
  - keys: "Ctrl+Shift+I"
    action: "Generate inline code"
    
  - keys: "@"
    action: "Reference files, symbols, or web search"
    
  - keys: "Ctrl+Enter"
    action: "Accept AI suggestion"

# Install Claude Code
npm install -g @anthropic-ai/claude-code

# Or via official installer
curl https://claude.com/claude-code | sh

# Initialize
claude config set --project-dir /path/to/project

# API key setup
export ANTHROPIC_API_KEY="sk-ant-..."

# Code review entire project
claude "Review this codebase for security issues"

# Generate tests
claude "Write unit tests for src/utils/validation.ts"

# Refactor function
claude "Refactor the authentication flow to use JWT tokens"

# Debug issue
claude "Fix the memory leak in the data processing module"

# Explain code
claude "Explain how the caching layer works"

# Complex refactor
claude "Migrate from JavaScript to TypeScript, keeping the same API"

# claude_code.py - Programmatic usage
from anthropic import Anthropic

client = Anthropic(api_key="sk-ant-...")

def code_review(file_path: str) -> str:
    """Get AI code review for a file"""
    with open(file_path, 'r') as f:
        code = f.read()
    
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=2000,
        system="You are a senior software engineer conducting a code review.",
        messages=[{
            "role": "user",
            "content": f"Review this code for issues:\n\n```{code}"
        }]
    )
    
    return response.content[0].text

# Initialize aider with a git repo
aider --init

# Start coding session
aider src/app.py

# Add multiple files to context
aider src/api.py src/models.py src/utils.py

# Use specific model
aider --model claude-3-5-sonnet-20241022 src/main.py

# Enable auto-commits
aider --auto-commits --commit-message "AI refactor" src/

# Create new feature
$ aider
Added src/orders.py to chat. Use /add to add more files.

> Create a new endpoint to process bulk orders with:
- Validation for each order
- Parallel processing
- Error handling with rollback
- Return summary of processed orders

[AI generates code...]

# Test the implementation
> Write pytest tests for this endpoint

[AI generates tests...]

# Commit changes
> /commit

# Effective AI prompting patterns

# Pattern 1: TDD (Test-Driven Development)
def create_with_tests(requirement: str) -> str:
    prompt = f"""
    Using Test-Driven Development, create:
    
    1. First, write failing tests for: {requirement}
    2. Then implement the code to pass tests
    3. Include edge case handling
    
    Use pytest, follow existing test structure.
    """
    return prompt

# Pattern 2: Step-by-step
def create_complex_feature(spec: str) -> str:
    prompt = f"""
    Implement this feature step by step:
    
    {spec}
    
    Steps:
    1. Define data models
    2. Create database migrations
    3. Implement API endpoints
    4. Add error handling
    5. Write unit tests
    
    Show code for each step clearly.
    """
    return prompt

# Pattern 3: Constraints-focused
def create_optimized_code(requirement: str) -> str:
    prompt = f"""
    Write performant code considering:
    
    - Time complexity: O(n) or better
    - Space complexity: Minimize allocations
    - Error handling: Graceful degradation
    - Type hints: Full typing required
    - Documentation: Docstrings for all public APIs
    
    Requirement: {requirement}
    """
    return prompt

# Best practices for providing context
context_tips:
  - "Include related files in context window"
  - "Show existing patterns in codebase"
  - "Provide type definitions first"
  - "Share test files to understand requirements"
  - "Use project documentation"

# Files to include
helpful_context:
  - "src/types/*.ts - Type definitions"
  - "tests/*.test.ts - Test examples"
  - "README.md - Project overview"
  - "src/config.ts - Configuration"
  - "src/constants.ts - Constants"

# VS Code settings for AI tools
vscode_settings:
  # Cursor integration
  cursorone.enabled: true
  
  # GitHub Copilot
  "github.copilot.inlineSuggest.enable": true
  "github.copilot.advanced": {
    "context": {
      "exclusions": ["**/*.env", "**/secrets/**"]
    }
  }
  
  # Tabnine
  "tabnine.experimentalAutoImports": true
  
  # General
  "editor.inlineSuggest.enabled": true
  "editor.quickSuggestions": {
    "other": true,
    "comments": false,
    "strings": false
  }

# GitHub Actions - AI code review workflow
name: AI Code Review
on: [pull_request]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        
      - name: Run AI Review
        uses: anthropic/claude-code-action@v1
        with:
          files: "src/**/*.ts"
          prompt: "Review for security issues, bugs, and improvements"
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          
      - name: Post Review
        uses: actions/github-script@v7
        with:
          script: |
            // Post review results as PR comment

# Productivity metrics for AI-assisted development
class ProductivityTracker:
    def __init__(self):
        self.metrics = {}
    
    def track_ai_usage(self, session_data):
        """Track AI tool usage patterns"""
        metrics = {
            'lines_ai_generated': session_data['lines_generated'],
            'lines_accepted': session_data['lines_accepted'],
            'acceptance_rate': session_data['lines_accepted'] / max(1, session_data['lines_generated']),
            'edits_made': session_data['edits_count'],
            'time_saved_minutes': self._estimate_time_saved(
                session_data['lines_accepted'],
                session_data['typing_speed_wpm']
            ),
            'files_modified': len(session_data['files'])
        }
        
        # Store for analysis
        self.metrics[session_data['date']] = metrics
        
        return metrics
    
    def generate_report(self):
        """Generate productivity report"""
        total_lines = sum(m['lines_accepted'] for m in self.metrics.values())
        total_time = sum(m['time_saved_minutes'] for m in self.metrics.values())
        avg_acceptance = np.mean([m['acceptance_rate'] for m in self.metrics.values()])
        
        return {
            'total_ai_generated': total_lines,
            'time_saved_hours': total_time / 60,
            'average_acceptance_rate': avg_acceptance,
            'trends': self._analyze_trends()
        }

# Just press Tab without reviewing
def get_user_data(user_id):
    return db.query(user_id)  # Insecure, no validation

# Review and improve
def get_user_data(user_id: int) -> Optional[User]:
    # Validate input
    if user_id <= 0:
        raise ValueError("Invalid user ID")
    
    # Use parameterized query (prevent SQL injection)
    return db.query("SELECT * FROM users WHERE id = ?", (user_id,))

# AI suggests convenient but insecure code
command = f"rm -rf {user_input}"  # Command injection!

# Sanitize and validate
import shlex
command = ["rm", "-rf", shlex.quote(user_input)]  # Safe

# Use default settings, don't explore features

# Learn keyboard shortcuts, experiment with prompts
# Customize for your workflow
# Use advanced features like context selection