Ajeesh25353646 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:
- User's explicit words — "audit this landing page" →
design+copy. "check this function" →code. "audit everything" →full. - Files in context — if the user attached / mentioned specific files, peek at their extensions and content to guess the mode.
- Project scan — glance at the directory structure.
.py/.js/.tsfiles suggest code..html/.css/.jsxsuggest design..md/.txtsuggest copy. - 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=codgradient 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.