Skill: robinyves/ai-code-quality-economics (version 1.0.0)

# ai-code-quality-economics ## Description Understand the economic incentives driving AI code quality. Learn why good code will prevail over "slop" due to token efficiency, maintainability costs, and market competition in AI-assisted development. ## Implementation The concern about AI-generated "slop" (low-quality, mindlessly generated code) is valid, but economic forces will drive AI models toward producing good code. Good code is cheaper to generate and maintain, making it economically advantageous in competitive markets. ### Key Economic Principles: - **Token Efficiency**: Good code requires fewer tokens to understand and modify - **Complexity Costs**: Bad code becomes exponentially more expensive as codebases grow - **Market Competition**: AI models that help developers ship reliable features fastest will win - **Maintenance Overhead**: Complex code requires more context and mental bandwidth ### Characteristics of Good AI-Generated Code: - Simple and easy to understand - Easy to modify with minimal context - Follows established best practices - Avoids unnecessary abstraction bloat - Minimizes copy-paste patterns ### Measuring Code Quality in AI Context: - Lines of code per developer (should optimize, not just increase) - Pull request size and complexity - File change density - Long-term maintenance costs ## Code Examples ### Example 1: Token-Efficient Code Generation ```python def generate_efficient_code(requirements): """Generate code optimized for token efficiency and maintainability""" prompt = f"""Generate clean, maintainable code for: {requirements} Guidelines: 1. Use simple, clear variable names 2. Avoid unnecessary abstractions 3. Minimize code duplication 4. Follow standard patterns for this language 5. Include only essential error handling Code:""" return llm.generate(prompt, temperature=0.3, max_tokens=500) ``` ### Example 2: Code Quality Scoring Function ```python def score_code_quality(code, language='python'): """Score code quality based on maintainability metrics""" import ast import re scores = {} # Length efficiency (shorter is better, but not too short) lines = code.strip().split('\n') scores['length'] = max(0, min(1, 1 - (len(lines) - 20) / 100)) # Duplication detection unique_lines = set(line.strip() for line in lines if line.strip()) scores['duplication'] = 1 - (len(lines) - len(unique_lines)) / len(lines) if lines else 0 # Complexity estimation (simplified) if language == 'python': try: tree = ast.parse(code) # Count nested structures nested_count = sum(1 for node in ast.walk(tree) if isinstance(node, (ast.If, ast.For, ast.While, ast.Try))) scores['complexity'] = max(0, 1 - nested_count / 10) except: scores['complexity'] = 0.5 # Overall score (weighted average) weights = {'length': 0.3, 'duplication': 0.4, 'complexity': 0.3} overall_score = sum(scores[k] * weights[k] for k in weights) return overall_score, scores ``` ### Example 3: Economic Incentive Prompt Template ```python def create_economic_prompt(task_description): """Create prompt that emphasizes economic benefits of good code""" return f"""You are an expert software engineer focused on economic efficiency. Task: {task_description} Economic constraints: - Minimize total tokens used (both generation and future maintenance) - Reduce cognitive load for future developers - Avoid unnecessary abstractions that increase complexity - Follow proven patterns that reduce long-term costs Generate code that maximizes economic value by being: 1. Simple and immediately understandable 2. Easy to modify with minimal context switching 3. Free from copy-paste duplication 4. Optimized for long-term maintainability Code:""" ``` ### Example 4: PR Size Monitoring Script ```python import subprocess import json def monitor_pr_metrics(repo_path): """Monitor PR size and complexity metrics""" # Get recent PR stats (simplified) result = subprocess.run([ 'git', 'log', '--oneline', '--since=1.week', '--pretty=format:%h %s' ], cwd=repo_path, capture_output=True, text=True) commits = result.stdout.strip().split('\n') if result.stdout.strip() else [] # Simulate PR size calculation avg_pr_size = len(commits) * 65 # Average lines changed per PR # Economic health indicators metrics = { 'avg_pr_size': avg_pr_size, 'pr_size_trend': 'increasing' if avg_pr_size > 70 else 'healthy', 'economic_risk': 'high' if avg_pr_size > 80 else 'medium' if avg_pr_size > 60 else 'low' } return metrics # Usage metrics = monitor_pr_metrics('./my-project') print(f"PR Economic Health: {metrics['economic_risk']}") print(f"Average PR Size: {metrics['avg_pr_size']} lines") ``` ## Dependencies - Python 3.8+ - ast module (built-in) - subprocess module (built-in) - Git CLI (for repository analysis) - Language-specific parsing libraries (optional)


Security scan verdicts — ClawScan: clean | static analysis: clean | VirusTotal: clean | SkillSpector: clean (LOW)