Agentic CI/CD: Claude Code as a reviewer that never gets tired

name: AI Code Review
on:
  pull_request:
    types: [opened, synchronize]
 
jobs:
  ai-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Claude Code CLI
        run: |
          curl -fsSL https://claude.ai/install.sh | bash
          claude auth login --api-key ${{ secrets.CLAUDE_API_KEY }}
      
      - name: Run AI Review
        run: |
          claude review \
            --context "Our codebase uses React/TypeScript with strict linting" \
            --focus "security, performance, maintainability" \
            --pr-url ${{ github.event.pull_request.html_url }}

const REVIEW_PROMPTS = {
  'typescript': `
    Review this TypeScript code for:
    1. Type safety and proper typing
    2. Error handling edge cases
    3. Performance implications
    4. Maintainability and readability
    5. Security vulnerabilities
    
    Focus on React patterns and state management.
    Our coding standards:
    - Use functional components with hooks
    - Avoid direct DOM manipulation
    - Use TypeScript strictly (no 'any' types)
    - Implement proper error boundaries
  `,
  
  'python': `
    Review this Python code for:
    1. PEP 8 compliance and readability
    2. Exception handling and robustness
    3. Database query optimization
    4. Memory usage patterns
    5. Security considerations (SQL injection, input validation)
    
    Our standards:
    - Use type hints where appropriate
    - Implement proper logging
    - Use context managers for resources
    - Follow DRY principles
  `,
  
  'infrastructure': `
    Review this infrastructure code for:
    1. Security best practices
    2. Cost optimization
    3. Scalability concerns
    4. Disaster recovery
    5. Compliance requirements
    
    Focus on AWS-specific best practices and cost optimization.
  `
};

interface ReviewComment {
  file: string;
  line: number;
  severity: 'critical' | 'major' | 'minor' | 'suggestion';
  category: 'security' | 'performance' | 'maintainability' | 'best-practice';
  message: string;
  suggestion?: string;
  confidence: number; // 0-1 AI confidence score
}
 
// Example generated comment
{
  file: 'src/components/UserProfile.tsx',
  line: 42,
  severity: 'major',
  category: 'security',
  message: 'Direct user input in innerHTML creates XSS vulnerability',
  suggestion: 'Use DOMPurify or React\'s dangerouslySetInnerHTML with sanitization',
  confidence: 0.95
}

// Context injection
const context = {
  recentChanges: getRecentChanges(prFiles),
  architecturalChanges: detectArchitecturalImpact(prFiles),
  dependencyUpdates: getDependencyUpdates(prFiles),
  performanceBaseline: getPerformanceMetrics()
};
 
// Enhanced review prompt
const enhancedPrompt = `
  Review these changes with context:
  - Recent changes: ${context.recentChanges}
  - Architectural impact: ${context.architecturalChanges}
  - Dependency updates: ${context.dependencyUpdates}
  - Performance baseline: ${context.performanceBaseline}
  
  Focus on how these changes interact with recent work.
`;

# Quality gate configuration
quality_gates:
  critical_issues:
    max_allowed: 0
    block_pr: true
  major_issues:
    max_allowed: 3
    block_pr: false
  performance_regression:
    max_allowed: 5%
    block_pr: true
  security_violations:
    max_allowed: 0
    block_pr: true

interface Feedback {
  prId: string;
  aiComment: ReviewComment;
  humanAction: 'accepted' | 'rejected' | 'modified';
  reasoning: string;
}
 
// Feedback loop
function collectFeedback(feedback: Feedback) {
  // Store feedback for training
  trainingData.push({
    prompt: generatePrompt(feedback.prId),
    response: feedback.aiComment,
    expected: feedback.humanAction,
    reasoning: feedback.reasoning
  });
  
  // Retrain model periodically
  if (trainingData.length % 100 === 0) {
    retrainModel(trainingData);
  }
}

graph TD
    A[Code Submitted] --> B[AI Review]
    B --> C{Critical Issues?}
    C -->|Yes| D[Block PR - Immediate Attention]
    C -->|No| E[Human Review]
    E --> F{Complex Changes?}
    F -->|Yes| G[Full Human Review]
    F -->|No| H[AI Comments + Human Oversight]
    H --> I[Approval]

const reviewStrategies = {
  'hotfix': 'strict + security focus',
  'feature': 'balanced + performance focus',
  'refactor': 'maintainability + readability focus',
  'dependency-update': 'security + compatibility focus'
};
 
// Dynamic review configuration
const reviewConfig = {
  severityThresholds: reviewStrategies[prType],
  focusAreas: getFocusAreasFor(prType),
  reviewDepth: getReviewDepthFor(prType)
};

// Confidence-based routing
function routeReviewComment(comment: ReviewComment) {
  if (comment.confidence < 0.7) {
    // Flag for human review
    flagForHumanReview(comment);
  } else if (comment.severity === 'critical') {
    // Always show critical issues
    return comment;
  } else {
    // Show as suggestion
    return { ...comment, type: 'suggestion' };
  }
}

// Chunked file review
async function reviewLargeFile(file: string, content: string) {
  const chunks = splitFileIntoLogicalChunks(content);
  const results = [];
  
  for (const chunk of chunks) {
    const review = await claudeReviewChunk(chunk, context);
    results.push(review);
  }
  
  return consolidateResults(results);
}

// Review quality metrics
const qualityMetrics = {
  falsePositiveRate: calculateFalsePositiveRate(),
  missedIssueRate: calculateMissedIssueRate(),
  developerSatisfaction: getDeveloperSatisfaction(),
  reviewAccuracy: calculateReviewAccuracy()
};
 
// Alert when quality drops
if (qualityMetrics.falsePositiveRate > 0.2) {
  triggerQualityReview();
}

const specializedAgents = {
  security: new SecurityReviewer(),
  performance: new PerformanceProfiler(),
  accessibility: new AccessibilityChecker(),
  architecture: new ArchitectureValidator()
};
 
// Multi-agent review
async function multiAgentReview(files: string[]) {
  const reviews = await Promise.all(
    Object.values(specializedAgents).map(agent => agent.review(files))
  );
  
  return consolidateReviews(reviews);
}

interface PredictiveReview {
  file: string;
  predictedIssues: Array<{
    type: string;
    severity: string;
    description: string;
    prevention: string;
  }>;
  suggestions: string[];
}
 
// Usage during development
function getPredictiveInsights(code: string) {
  return claude.predictIssues({
    code,
    context: projectContext,
    history: similarCodeIssues
  });
}