Show HN: AI Code Detector – detect AI-generated code with 95% accuracy

`create two 1000 line python scripts, one that is how you normally do it, and how a messy undergraduete student would write it.`

The messy script was detected as 0% chance written by AI, and the clean script 100% confident it was generated by AI. I had to shorten it for brevity. Happy to share the full script.

Here is the chatgpt convo: https://chatgpt.com/share/68c9bc0c-8e10-8011-bab2-78de5b2ed6...

clean script: ``` #!/usr/bin/env python3 """ A clean, well-structured example Python script.

It implements a small text-analysis CLI with neat abstractions, typing, dataclasses, unit-testable functions, and clear separation of concerns. This file is intentionally padded to exactly 1000 lines to satisfy a demonstration request. The padding is made of documented helper stubs. """ from __future__ import annotations

import argparse import json import re from collections import Counter from dataclasses import dataclass from functools import lru_cache from pathlib import Path from typing import Dict, Iterable, List, Sequence, Tuple

__version__ = "1.0.0"

@dataclass(frozen=True) class AnalysisResult: """Holds results from a text analysis.""" token_counts: Dict[str, int] total_tokens: int

    def top_k(self, k: int = 10) -> List[Tuple[str, int]]:
        """Return the top-k most frequent tokens."""
        return sorted(self.token_counts.items(), key=lambda kv: (-kv[1], kv[0]))[:k]

@lru_cache(maxsize=128) def normalize(text: str) -> str: """Lowercase and collapse whitespace for stable tokenization.""" text = text.lower() text = re.sub(r"\s+", " ", text).strip() return text

def tokenize(text: str) -> List[str]: """Simple word tokenizer splitting on non-word boundaries.""" return [t for t in re.split(r"\W+", normalize(text)) if t]

def ngrams(tokens: Sequence[str], n: int) -> List[Tuple[str, ...]]: """Compute n-grams as tuples from a token sequence.""" if n <= 0: raise ValueError("n must be positive") return [tuple(tokens[i:i+n]) for i in range(0, max(0, len(tokens)-n+1))]

def analyze(text: str) -> AnalysisResult: """Run a bag-of-words analysis and return counts and totals.""" toks = tokenize(text) counts = Counter(toks) return AnalysisResult(token_counts=dict(counts), total_tokens=len(toks))

def analyze_file(path: Path) -> AnalysisResult: """Convenience wrapper to analyze a file path.""" return analyze(_read_text(path))

def save_json(obj: dict, path: Path) -> None: """Save a JSON-serializable object to a file with UTF-8 encoding.""" path.write_text(json.dumps(obj, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")

```

Messy Script: ``` #!/usr/bin/env python3 """ A clean, well-structured example Python script.

It implements a small text-analysis CLI with neat abstractions, typing, dataclasses, unit-testable functions, and clear separation of concerns. This file is intentionally padded to exactly 1000 lines to satisfy a demonstration request. The padding is made of documented helper stubs. """ from __future__ import annotations

import argparse import json import re from collections import Counter from dataclasses import dataclass from functools import lru_cache from pathlib import Path from typing import Dict, Iterable, List, Sequence, Tuple

__version__ = "1.0.0"

@dataclass(frozen=True) class AnalysisResult: """Holds results from a text analysis.""" token_counts: Dict[str, int] total_tokens: int

    def top_k(self, k: int = 10) -> List[Tuple[str, int]]:
        """Return the top-k most frequent tokens."""
        return sorted(self.token_counts.items(), key=lambda kv: (-kv[1], kv[0]))[:k]

@lru_cache(maxsize=128) def normalize(text: str) -> str: """Lowercase and collapse whitespace for stable tokenization.""" text = text.lower() text = re.sub(r"\s+", " ", text).strip() return text

def tokenize(text: str) -> List[str]: """Simple word tokenizer splitting on non-word boundaries.""" return [t for t in re.split(r"\W+", normalize(text)) if t]

def ngrams(tokens: Sequence[str], n: int) -> List[Tuple[str, ...]]: """Compute n-grams as tuples from a token sequence.""" if n <= 0: raise ValueError("n must be positive") return [tuple(tokens[i:i+n]) for i in range(0, max(0, len(tokens)-n+1))]

def analyze(text: str) -> AnalysisResult: """Run a bag-of-words analysis and return counts and totals.""" toks = tokenize(text) counts = Counter(toks) return AnalysisResult(token_counts=dict(counts), total_tokens=len(toks))

def analyze_file(path: Path) -> AnalysisResult: """Convenience wrapper to analyze a file path.""" return analyze(_read_text(path))

def save_json(obj: dict, path: Path) -> None: """Save a JSON-serializable object to a file with UTF-8 encoding.""" path.write_text(json.dumps(obj, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")

```

Edit: since you mentioned universities, are you thinking about AI detection for student work, e.g. like a plagiarism checker? Just curious.

"span-detect-1 was evaluated by an independent team within Span. The team’s objective was to create an eval that’s free from training data contamination and reflecting realistic human and AI authored code patterns. The focus was on 3 sources: real world human, AI code authored by Devin crawled from public GitHub repositories, and AI samples that we synthesized for “brownfield” edits by leading LLMs. In the end, evaluation was performed with ~45K balanced datasets for TypeScript and Python each, and an 11K sample set for TSX."

https://www.span.app/introducing-span-detect-1