# Using SonarQube for comprehensive clone detection
sonar-scanner -Dsonar.projectKey=myproject \
              -Dsonar.sources=./src \
              -Dsonar.analysis.mode=preview \
              -Dsonar.cpd.minimumTokens=50

# PMD Copy-Paste Detector
pmd cpd --minimum-tokens 100 --files src/ --format xml

# NiCad for near-miss clone detection
nicad3 functions java src/ systems/

import ast
import hashlib
from collections import defaultdict

class CodeCloneDetector:
    def __init__(self, similarity_threshold=0.8):
        self.similarity_threshold = similarity_threshold
        self.function_hashes = defaultdict(list)
    
    def extract_function_signature(self, node):
        """Extract normalized function signature for comparison"""
        # Remove variable names, keep structure
        normalized = self.normalize_ast(node)
        return hashlib.md5(normalized.encode()).hexdigest()
    
    def detect_clones(self, file_paths):
        """Detect potential code clones across files"""
        clones = []
        for file_path in file_paths:
            with open(file_path, 'r') as f:
                tree = ast.parse(f.read())
                
            for node in ast.walk(tree):
                if isinstance(node, ast.FunctionDef):
                    signature = self.extract_function_signature(node)
                    self.function_hashes[signature].append({
                        'file': file_path,
                        'function': node.name,
                        'line': node.lineno
                    })
        
        # Identify duplicates
        for signature, locations in self.function_hashes.items():
            if len(locations) > 1:
                clones.append({
                    'signature': signature,
                    'locations': locations,
                    'clone_count': len(locations)
                })
        
        return clones

Quality Metrics Dashboard:
  code_duplication:
    threshold: 5%
    current: 15%  # 3x above threshold
    trend: increasing
    
  cyclomatic_complexity:
    avg_threshold: 10
    current_avg: 18
    trend: increasing
    
  technical_debt_ratio:
    threshold: 5%
    current: 12%
    trend: increasing
    
  test_coverage:
    threshold: 80%
    current: 65%
    trend: decreasing
    
  maintainability_index:
    threshold: 20+
    current: 15
    trend: decreasing

// Anti-Pattern 1: Repeated API handling logic
// Found in multiple components - clear AI copy-paste
function fetchUserData(userId) {
    try {
        const response = await fetch(`/api/users/${userId}`);
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        const data = await response.json();
        return data;
    } catch (error) {
        console.error('Error fetching user data:', error);
        return null;
    }
}

// Anti-Pattern 2: Identical validation logic
// Repeated across 8 different forms
function validateEmail(email) {
    const re = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
    return re.test(email);
}

// Anti-Pattern 3: Copy-paste error handling
// Same pattern in 15+ components
.catch(error => {
    console.error('An error occurred:', error);
    setError('Something went wrong');
    setLoading(false);
});

Traditional Review Process:
1. Human writes code (15-30 minutes)
2. Thorough review and discussion (10-15 minutes)
3. Iteration and improvement (5-10 minutes)

AI-Assisted Process (Problematic):
1. AI generates code (30 seconds)
2. Quick acceptance without review (30 seconds)
3. Integration without testing (2 minutes)

Code Clone Impact Analysis:
- 1 instance: Normal maintenance cost
- 2-3 clones: 2x maintenance cost
- 4-6 clones: 4x maintenance cost
- 7+ clones: 8x+ maintenance cost (exponential growth)

Bug Fix Propagation:
- Bug found in one instance
- Must be fixed in N locations
- Risk of inconsistent fixes
- Testing complexity multiplies

// Original AI-generated authentication logic
// Copied to 12 different components
async function authenticate(credentials) {
    const response = await fetch('/api/auth', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(credentials)
    });
    
    if (response.status === 200) {
        const token = response.headers.get('Authorization');
        localStorage.setItem('token', token);
        return true;
    }
    return false;
}

// Security vulnerability discovered: token exposure in localStorage
// Now requires fixing in 12 locations
// Risk of missing instances during fix
// Testing requires validation across all 12 components

// AI-generated code often prioritizes readability over performance
// Repeated across multiple components:

function processUserList(users) {
    return users
        .filter(user => user.active)
        .map(user => ({
            ...user,
            displayName: `${user.firstName} ${user.lastName}`
        }))
        .sort((a, b) => a.displayName.localeCompare(b.displayName));
}

// Performance issues:
// 1. Recreated on every render
// 2. No memoization
// 3. Inefficient sorting algorithm for large lists
// 4. Duplicated across 8 components

Testing Burden Calculation:
- Core functionality: 10 test cases
- 5 code clones: 50 test cases required
- Maintenance: 5x update complexity
- Regression risk: High (changes must be synchronized)

## AI-Generated Code Review Checklist

### Context and Integration
- [ ] Does this leverage existing project utilities?
- [ ] Is this consistent with established patterns?
- [ ] Are there similar functions elsewhere that could be refactored?
- [ ] Does this follow our coding standards?

### Code Quality
- [ ] Is error handling appropriate for our error strategy?
- [ ] Are logging and monitoring integrated properly?
- [ ] Does this handle edge cases specific to our domain?
- [ ] Is performance adequate for expected load?

### Duplication Prevention
- [ ] Search codebase for similar implementations
- [ ] Can this be abstracted into a reusable utility?
- [ ] Does this create opportunities for consolidation?
- [ ] Are there existing libraries that handle this?

### Testing and Documentation
- [ ] Are tests comprehensive and project-specific?
- [ ] Is documentation updated to reflect new patterns?
- [ ] Are integration points properly tested?
- [ ] Does this introduce breaking changes?

# .github/workflows/ai-quality-check.yml
name: AI Code Quality Check
on: [pull_request]

jobs:
  quality-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Code Clone Detection
        run: |
          # Run clone detection
          pmd cpd --minimum-tokens 50 --files src/
          
      - name: Complexity Analysis
        run: |
          # Check cyclomatic complexity
          lizard src/ --CCN 10
          
      - name: Pattern Analysis
        run: |
          # Custom script to detect AI patterns
          python scripts/detect_ai_patterns.py
          
      - name: Quality Gate
        run: |
          # Fail if quality thresholds exceeded
          python scripts/quality_gate.py

Poor Prompt:
"Create a function to validate email addresses"

Better Prompt:
"Create an email validation function that:
- Uses our existing ValidationUtils class
- Follows our error handling pattern (throw ValidationError)
- Integrates with our logging system
- Includes JSDoc documentation
- Returns detailed validation results
- Handles our specific business rules (no .test domains)"

// Project-specific AI prompt template
interface PromptContext {
  projectPatterns: string[];
  existingUtilities: string[];
  codingStandards: string[];
  architecturalConstraints: string[];
}

function generateContextualPrompt(
  requirement: string, 
  context: PromptContext
): string {
  return `
Create ${requirement} that:

MUST USE existing utilities:
${context.existingUtilities.join('\n')}

MUST FOLLOW patterns:
${context.projectPatterns.join('\n')}

MUST COMPLY with standards:
${context.codingStandards.join('\n')}

MUST RESPECT constraints:
${context.architecturalConstraints.join('\n')}

Include comprehensive error handling, logging, and tests.
  `;
}

// Step 1: Identify clone clusters
const cloneClusters = await detectCodeClones({
  threshold: 0.8,
  minimumLines: 10
});

// Step 2: Prioritize by impact
const prioritizedClusters = cloneClusters
  .sort((a, b) => 
    (b.instances.length * b.complexity) - 
    (a.instances.length * a.complexity)
  );

// Step 3: Create abstractions
class RefactoringPlan {
  createAbstraction(cluster) {
    // Extract common functionality
    // Identify variation points
    // Design configurable interface
    // Plan migration strategy
  }
  
  generateMigrationPlan(cluster) {
    return {
      phases: this.planPhases(cluster),
      riskAssessment: this.assessRisks(cluster),
      testingStrategy: this.planTesting(cluster),
      rollbackProcedure: this.planRollback(cluster)
    };
  }
}

// Common patterns identified from AI code analysis
abstract class ProjectUtility {
  abstract getDescription(): string;
  abstract getUsageExamples(): string[];
  abstract validateInput(input: any): boolean;
}

class APIUtility extends ProjectUtility {
  // Consolidates 15+ duplicate API handling patterns
  static async makeRequest<T>(
    endpoint: string,
    options: RequestOptions
  ): Promise<APIResponse<T>> {
    // Centralized error handling
    // Consistent logging
    // Standardized retry logic
    // Project-specific authentication
  }
}

class ValidationUtility extends ProjectUtility {
  // Consolidates 20+ validation functions
  static validateEmail(email: string): ValidationResult {
    // Business-specific rules
    // Consistent error messages
    // Centralized validation logic
  }
}

// VS Code extension for AI quality control
class AIQualityAssistant {
  onCodeGeneration(generatedCode: string) {
    const analysis = this.analyzeCode(generatedCode);
    
    if (analysis.hasPotentialDuplicate) {
      this.showWarning(
        'Similar code detected in project. Consider using existing utility.'
      );
      this.suggestExistingCode(analysis.similarCode);
    }
    
    if (analysis.missesProjectPatterns) {
      this.showSuggestion(
        'Generated code doesn\'t follow project patterns.',
        analysis.suggestedImprovements
      );
    }
  }
  
  suggestRefactoring(filePath: string) {
    const duplicates = this.findDuplicatesInFile(filePath);
    if (duplicates.length > 2) {
      this.showRefactoringOpportunity(duplicates);
    }
  }
}

// ESLint plugin for AI-generated code quality
module.exports = {
  rules: {
    'no-ai-duplication': {
      create(context) {
        return {
          FunctionDeclaration(node) {
            const signature = extractFunctionSignature(node);
            if (isDuplicateSignature(signature)) {
              context.report({
                node,
                message: 'Potential code duplication detected. Consider refactoring.',
                suggest: [{
                  desc: 'Extract to utility function',
                  fix: fixer => generateUtilityRefactor(fixer, node)
                }]
              });
            }
          }
        };
      }
    },
    
    'enforce-project-patterns': {
      create(context) {
        return {
          Program(node) {
            const violations = checkProjectPatterns(node);
            violations.forEach(violation => {
              context.report({
                node: violation.node,
                message: `Code doesn't follow project pattern: ${violation.pattern}`,
                fix: fixer => applyProjectPattern(fixer, violation)
              });
            });
          }
        };
      }
    }
  }
};

# Quality metrics pipeline
quality_gates:
  code_duplication:
    threshold: 5%
    action: block_merge
    
  complexity_increase:
    threshold: 10%
    action: require_review
    
  test_coverage_decrease:
    threshold: 2%
    action: require_additional_tests
    
  ai_pattern_violations:
    threshold: 0
    action: suggest_improvements

class AutoRefactoringEngine:
    def analyze_pull_request(self, pr):
        changes = self.extract_changes(pr)
        duplicates = self.find_duplicates(changes)
        
        if len(duplicates) > 2:
            refactoring_plan = self.generate_refactoring_plan(duplicates)
            self.create_follow_up_issue(refactoring_plan)
            
    def generate_refactoring_plan(self, duplicates):
        return {
            'title': 'Refactor duplicate code patterns',
            'description': self.create_refactoring_description(duplicates),
            'implementation_steps': self.plan_refactoring_steps(duplicates),
            'estimated_effort': self.estimate_effort(duplicates),
            'benefits': self.calculate_benefits(duplicates)
        }

Week 1: Understanding AI limitations and biases
Week 2: Context-aware prompting techniques
Week 3: Code review for AI-generated code
Week 4: Refactoring and pattern recognition
Week 5: Quality tooling and automation
Week 6: Hands-on quality improvement project

# AI-Assisted Development Guidelines

## Before Using AI
1. Understand the problem context fully
2. Review existing solutions in the codebase
3. Identify relevant patterns and utilities
4. Define quality criteria for the solution

## During AI Generation
1. Provide rich context in prompts
2. Specify project-specific requirements
3. Request multiple alternative approaches
4. Ask for explanation of design decisions

## After AI Generation
1. Thoroughly review and understand the code
2. Check for duplicates and pattern violations
3. Adapt code to project conventions
4. Add comprehensive tests
5. Update documentation as needed

## Red Flags
- Code that looks identical to existing implementations
- Generic solutions that ignore project context
- Missing error handling or logging
- Inconsistent with established patterns
- No tests or documentation

Monthly Quality Review Agenda:
1. Code duplication metrics review
2. Recent AI-generated code analysis
3. Refactoring opportunity identification
4. Pattern and utility updates
5. Tool and process improvements
6. Team feedback and suggestions

AI Quality Mentorship Program:
- Senior developers mentor juniors on AI usage
- Pair programming sessions for AI-generated code review
- Knowledge sharing on effective prompting
- Collaborative refactoring sessions
- Quality pattern development

Quality Dashboard:
  code_duplication_ratio:
    target: <5%
    current: 12%
    trend: improving
    
  maintenance_velocity:
    target: stable
    current: 25% slower
    trend: improving
    
  bug_density:
    target: <0.5/KLOC
    current: 1.2/KLOC
    trend: stable
    
  refactoring_frequency:
    target: monthly
    current: quarterly
    trend: improving

Process Metrics:
  ai_code_review_time:
    target: <15 minutes
    current: 22 minutes
    trend: improving
    
  pattern_compliance:
    target: >90%
    current: 75%
    trend: improving
    
  utility_reuse_rate:
    target: >80%
    current: 45%
    trend: improving

Quality Initiative Costs:
- Tool implementation: $50K
- Training and process development: $100K
- Ongoing monitoring and maintenance: $25K/year

Quality Returns (Annual):
- Reduced maintenance costs: $200K
- Faster feature development: $150K
- Reduced bug fixing costs: $75K
- Improved developer productivity: $100K

Net ROI: 400% in first year

interface QualityAI {
  analyzeCodeGeneration(code: string, context: ProjectContext): QualityReport;
  suggestImprovements(code: string): Improvement[];
  detectPatternViolations(code: string): Violation[];
  generateRefactoringPlan(duplicates: CodeClone[]): RefactoringPlan;
}

class IntelligentQualityGate implements QualityAI {
  // AI system that learns project patterns
  // Provides contextual quality feedback
  // Suggests improvements based on project history
  // Predicts maintenance issues
}

class QualityPredictor:
    def predict_maintenance_burden(self, code_changes):
        # Use ML to predict future maintenance costs
        # Based on code complexity, duplication, and historical data
        pass
    
    def recommend_refactoring_priority(self, codebase):
        # Identify highest-impact refactoring opportunities
        # Optimize for maximum quality improvement per effort
        pass