Ai audit

AI Audit Skill

Audit any project or piece of content for recognizable AI fingerprints — the visual, copy, and code patterns that AI models default to. The skill produces a structured report you can act on directly.

How Mode Detection Works

The skill picks the right audit scope automatically, using this priority:

1. User's explicit words — "audit this landing page" → design+copy. "check this function" → code. "audit everything" → full.
2. Files in context — if the user attached / mentioned specific files, peek at their extensions and content to guess the mode.
3. Project scan — glance at the directory structure. .py/.js/.ts files suggest code. .html/.css/.jsx suggest design. .md/.txt suggest copy.
4. Fallback — if nothing is clear, run full (all three modes).

Override: Pass --mode copy, --mode design, --mode code, or --mode full to force a specific scope.

When the mode is ambiguous (e.g., user just says "audit this" with nothing else to go on), ask briefly rather than guessing wrong.

Workflow

When invoked, follow these steps:

1. Determine Scope

Figure out the mode. If forced via --mode, use that. Otherwise, apply the priority chain above. If truly ambiguous after checking, ask.

2. Load Reference Rules

Based on the mode, read the relevant reference file(s):

Mode	Reference file	What it covers
copy	references/copy-fingerprints.md	LLM prose tells, buzzwords, em dashes, cadence patterns
design	references/design-fingerprints.md	Visual anti-patterns, overused fonts, AI color palettes, layout patterns
code	references/code-fingerprints.md	AI comment patterns, over-engineering, generic naming, hallucinated imports
full	All three	Everything — this is the comprehensive audit

Read the reference file(s) in full — each is designed to load on demand and contains the specific patterns to look for.

3. Scan the Target

If files are specified (user named a file, passed a URL, or a file is in their message):

• Read the file(s) or fetch the URL content
• Apply the relevant rule set(s) from the reference files
• For each rule, check the content systematically

If no files are specified but the user wants to audit the project:

• Scan the current directory for relevant files (by extension per mode)
• Pick the most likely targets (e.g., main pages, key components, entry points)
• Sample a representative set — don't read every file in a large project
• Apply the relevant rule set(s)

If the user pasted content inline, audit that content directly.

4. Generate the Report

Print the report to stdout AND write it to ai-audit-report.md in the current directory. Optionally also write ai-audit-report.json for programmatic use.

Use the report template below. Every finding should include enough context for someone reading the report to understand what was found, why it's a fingerprint, and how to fix it.

5. Natural Next Steps

After the report lands in context and on disk, Claude or the user can naturally act on it — fix the em dashes, swap out the font, clean up the code — because the report lists actionable fixes alongside each finding. No special fix mode is needed; the report is the trigger.

Report Template

# AI Audit Report

**Target:** <file(s) or description>
**Mode:** copy | design | code | full
**Date:** <date>

## Summary

- **Total findings:** N
- **AI Slop Score:** 0–4 (0 = heavy AI fingerprints, 4 = no detectable tells)
- **By severity:** P0: X, P1: Y, P2: Z
- **By category:** copy: X, design: Y, code: Z

## Findings

### [P0|P1|P2] Finding Title
- **Location:** `file.ts:42`
- **Category:** copy/design/code
- **What:** The exact text or pattern found
- **Why it's a tell:** Brief explanation of why this reads as AI-generated
- **Fix:** Specific, actionable suggestion for what to change it to

...

## No Issues Found

If the audit finds no detectable AI fingerprints, report that plainly.
No fake findings. If it's clean, say so.

Severity Guide

• P0 — Definite slop: Unambiguously an AI tell. Em dashes in bulk, --mode=cod gradient text, overused fonts, LLM cadence patterns. Should be fixed.
• P1 — Likely slop: Strong signal. Cream/beige palette, single font for everything, aphoristic copy. Worth fixing but may be intentional in context.
• P2 — Advisory: Weak signal. Something that could be AI-generated but might also be a deliberate choice. Flag it but don't insist.

Scoring

The AI Slop Score follows Impeccable's convention:

Score	Meaning
4	No detectable AI fingerprints — clean
3	Minor tells — a few patterns but not pervasive
2	Moderate — several clear signals
1	Heavy — obvious AI generation throughout
0	AI slop gallery — every page/section has multiple tells

Score from 4 and subtract per finding: P0 = -1.5, P1 = -1, P2 = -0.5. Clamp to [0, 4].

Important Constraints

• Be honest about clean content. The skill's credibility depends on not hallucinating findings. If content reads human-written, say so.
• Be specific, not vague. Don't say "this looks AI-generated" without pointing to a concrete pattern from the reference file. Every finding must have a detectable, nameable pattern behind it.
• Don't over-audit dependencies. Code audit should focus on the project's own code, not library code in node_modules/, .venv/, or similar.
• Severity matters. A single em dash in 2000 words is P2, not P0. Context and density are everything.