Detection Strategies Reference

This is the master list of all 38 detection strategies that Cadence uses to identify AI-generated content. Strategies are split between Git repository analysis (18) and web content analysis (20).

Git Repository Detection Strategies (18 Total)

Cadence applies these 18 strategies to Git commit history to detect AI-generated code patterns.

Size & Velocity Analysis

Code Quality Analysis

Anomaly & Pattern Detection

Precision & Template Analysis

Web Content Detection Strategies (20 Total)

Cadence applies these 20 strategies to website content to detect AI-generated text patterns.

Language & Tone Analysis

Accessibility & HTML Analysis

Style & Design Analysis

How Scoring Works

Each strategy produces a suspicion score from 0-100:

• 0-30: Low suspicion (normal)
• 31-60: Medium suspicion (worth investigating)
• 61-100: High suspicion (likely AI-generated)

Multiple Strategy Consensus

Cadence doesn't flag content based on a single strategy. Instead:

1. Individual scores - Each strategy produces 0-100 score
2. Consensus - Multiple strategies must report high scores
3. Weighting - Some strategies weighted more heavily than others
4. Final score - Overall suspicion from 0-100

Examples:

• ✅ Flagged by 5+ strategies = Very likely AI-generated
• ⚠️ Flagged by 2-3 strategies = Worth investigating
• ❌ Flagged by 1 strategy = Likely false positive

Configuring Detection Strategies

Adjusting Sensitivity (Git)

Most Git strategies use configurable thresholds in _threshold-reference.md:

thresholds:
  # Lower values = more sensitive (catches more)
  suspicious_additions: 300      # Default: 500
  max_additions_per_min: 50       # Default: 100
  min_time_delta_seconds: 30      # Default: 60
  max_files_per_commit: 20        # Default: 50
  max_addition_ratio: 0.80        # Default: 0.95

Disabling Strategies

Disable specific strategies if they produce false positives:

strategies:
  disabled_strategies:
    - "emoji_usage"           # Disable emoji detection
    - "special_chars"         # Disable special character detection
    - "generic_language"      # Disable generic language (web)

Via environment:

export CADENCE_STRATEGIES_DISABLED="emoji_usage,special_chars"

Strategy Categories

By Type

• Git-only: Strategies 1-18 (commit history)
• Web-only: Strategies 1-20 (website content)
• Both: None (strategies are domain-specific)

By Severity Weight

• High: Velocity, Size, Timing (Git)
• Medium: Message analysis, Patterns
• Low: Emoji, Special characters (more prone to false positives)

Git Strategy Details

Velocity Analysis

• What it detects: Abnormally fast code generation
• Configurable: Yes (max_additions_per_min, max_deletions_per_min)
• Why it matters: Humans work at 20-50 lines/minute; AI can do 500+
• False positives: Bulk imports, automated code generation tools

Size Analysis

• What it detects: Unusually large commits
• Configurable: Yes (suspicious_additions, suspicious_deletions)
• Why it matters: Humans split work; AI might generate entire modules at once
• False positives: Legitimate large refactors, dependency updates

Timing Analysis

• What it detects: Rapid-fire commit bursts
• Configurable: Yes (min_time_delta_seconds)
• Why it matters: Automation leaves telltale timing patterns
• False positives: Merge conflict resolution, cherry-picking

File Dispersion Analysis

• What it detects: Commits affecting too many files
• Configurable: Yes (max_files_per_commit)
• Why it matters: Humans focus on 1-3 related files; AI generates across modules
• False positives: Large refactors, monorepo updates

Ratio Analysis

• What it detects: Imbalanced additions vs deletions
• Configurable: Yes (max_addition_ratio, min_deletion_ratio)
• Why it matters: AI-generated code is usually additions-heavy
• False positives: Feature additions, initial project setup

Message Analysis

• What it detects: Generic/vague commit messages
• Configurable: No
• Why it matters: AI often generates generic messages; humans are specific
• False positives: Quick fixes by humans with lazy messages

Naming Pattern Analysis

• What it detects: Generic variable/function names
• Configurable: No
• Why it matters: AI generates generic names; humans use semantic names
• False positives: Truly generic temporary code, DSLs

Structural Consistency

• What it detects: Overly uniform code structure
• Configurable: No
• Why it matters: AI generates templated structures; humans vary naturally
• False positives: Strict code style enforcement, generated boilerplate

Error Handling Analysis

• What it detects: Missing error handling
• Configurable: No
• Why it matters: AI often generates incomplete error handling
• False positives: Simple utility code that genuinely needs no error handling

File Extension Pattern

• What it detects: Unusual file type combinations
• Configurable: No
• Why it matters: Certain combinations suggest incomplete or automation-driven changes
• False positives: Legitimate diverse changes (e.g., code + docs + config)

Statistical Anomaly Detection

• What it detects: Deviations from baseline patterns
• Configurable: No
• Why it matters: AI changes look different from repository's natural patterns
• False positives: New developer on team, significant refactors

Burst Pattern Analysis

• What it detects: Clusters of rapid commits
• Configurable: No
• Why it matters: Automation creates burst patterns; humans work more evenly
• False positives: Intense work sessions by focused developers

Timing Anomaly Detection

• What it detects: Commits at unusual hours
• Configurable: No
• Why it matters: Automation doesn't sleep; finds overnight commits
• False positives: Remote employees, different timezones, night owls

Merge Commit Detection

• What it detects: Unusual merge patterns
• Configurable: No
• Why it matters: AI-generated code might have odd branching patterns
• False positives: Complex branching strategies, pull request merges

Precision Analysis

• What it detects: Excessive mechanical precision
• Configurable: Yes (enable_precision_analysis)
• Why it matters: AI generates very uniform, precise patterns
• False positives: Code generated by legitimate tools (scaffolding, generators)

Template Pattern Detection

• What it detects: Boilerplate/template code
• Configurable: No
• Why it matters: AI often uses templates; humans adapt them
• False positives: Legitimate scaffolding, framework setup code

Emoji Usage Detection

• What it detects: Emoji in commit messages
• Configurable: No (low priority strategy)
• Why it matters: Uncommon in AI-generated commits
• False positives: Developers who like emoji in messages

Special Character Detection

• What it detects: Unusual special character patterns
• Configurable: No (low priority strategy)
• Why it matters: Rare pattern in both human and AI code
• False positives: DSLs, special formatting, decorative comments

See Also

• Detection Strategies Guide - Detailed strategy explanations
• Threshold Reference - Configuration threshold tuning
• CLI Commands - Command-line analysis
• Configuration Guide - Full configuration options