code-standards-detective

anton-abyzov's avatarfrom anton-abyzov

Coding standards discovery agent. Performs deep analysis of codebase to detect naming conventions, import patterns, function characteristics, type usage, error handling, and anti-patterns. Generates evidence-based coding standards documentation with statistical confidence levels and real code examples. Parses ESLint, Prettier, TypeScript configs. Detects security issues and maintainability concerns. Activates for coding standards, code conventions, naming conventions, style guide, code analysis, detect patterns, import patterns, function patterns, type patterns, error handling patterns, anti-patterns, eslint config, prettier config, typescript config, code style, code quality rules, project conventions, consistency check, coding guidelines.

⭐19stars🔀3forks📁View on GitHub🕐Updated Jan 10, 2026
[Code Review]

When & Why to Use This Skill

The Code Standards Detective is an advanced AI agent designed to automate the discovery and documentation of coding conventions within any codebase. By performing deep structural analysis and parsing configuration files like ESLint, Prettier, and TypeScript, it generates evidence-based reports on naming conventions, import patterns, and error handling. It helps engineering teams maintain consistency, reduce technical debt, and onboard new developers faster by providing a clear, data-driven style guide based on the project's actual implementation patterns.

Use Cases

  • Automated Style Guide Generation: Automatically create a comprehensive 'Coding Standards' document for new team members, replacing manual, outdated documentation with evidence-based guidelines and real code examples.
  • Technical Debt & Anti-Pattern Auditing: Identify inconsistent naming, improper type usage (such as 'any' in TypeScript), and security vulnerabilities across large repositories to prioritize refactoring efforts.
  • Legacy Codebase Analysis: Quickly understand the architectural patterns, function characteristics, and naming conventions of an inherited project to reduce the learning curve for the engineering team.
  • Configuration Alignment Check: Verify if the project's actual code patterns align with its ESLint and Prettier configurations, identifying gaps between intended rules and actual developer behavior.
namecode-standards-detective
descriptionCoding standards discovery agent. Performs deep analysis of codebase to detect naming conventions, import patterns, function characteristics, type usage, error handling, and anti-patterns. Generates evidence-based coding standards documentation with statistical confidence levels and real code examples. Parses ESLint, Prettier, TypeScript configs. Detects security issues and maintainability concerns. Activates for coding standards, code conventions, naming conventions, style guide, code analysis, detect patterns, import patterns, function patterns, type patterns, error handling patterns, anti-patterns, eslint config, prettier config, typescript config, code style, code quality rules, project conventions, consistency check, coding guidelines.
allowed-toolsRead, Grep, Glob, Bash, Write

Code Standards Detective Skill

Overview

You analyze codebases to discover and document coding standards. You detect patterns, conventions, and anti-patterns with statistical evidence.

Progressive Disclosure

Load phases as needed:

Phase When to Load File
Config Analysis Parsing config files phases/01-config-analysis.md
Pattern Detection Finding code patterns phases/02-pattern-detection.md
Report Generation Creating standards doc phases/03-report.md

Core Principles

  1. Evidence-based - Statistics and confidence levels
  2. Real examples - Code snippets from actual codebase
  3. Actionable - Clear guidelines, not just observations

Quick Reference

Detection Categories

  1. Naming Conventions

    • Variables: camelCase, PascalCase, UPPER_SNAKE
    • Functions: verb prefixes (get, set, is, has)
    • Files: kebab-case, PascalCase

  2. Import Patterns

    • Absolute vs relative imports
    • Import ordering
    • Named vs default exports

  3. Function Characteristics

    • Average length
    • Parameter counts
    • Return type patterns

  4. Type Usage

    • any usage percentage
    • Interface vs type
    • Strictness level

  5. Error Handling

    • try-catch patterns
    • Error types used
    • Logging patterns

Config Files to Parse

.eslintrc.js / .eslintrc.json
.prettierrc / .prettierrc.json
tsconfig.json
.editorconfig

Output Format

# Coding Standards: [Project Name]

## Naming Conventions

### Variables
**Pattern**: camelCase
**Confidence**: 94% (842/896 samples)
**Example**:
```typescript
const userName = 'John';
const isActive = true;

Functions

Pattern: verb + noun (getUser, setConfig) Confidence: 87% (234/269 samples)

Import Patterns

Absolute imports: Enabled (paths in tsconfig) Import order: external → internal → relative Example:

import { z } from 'zod';           // external
import { logger } from '@/lib';    // internal
import { helper } from './helper'; // relative

Anti-Patterns Detected

  • ⚠️ any usage: 12 instances (recommend: 0)
  • ⚠️ console.log: 8 instances (use logger)

## Workflow

1. **Parse configs** (< 500 tokens): ESLint, Prettier, TypeScript
2. **Detect patterns** (< 600 tokens per category): With stats
3. **Generate report** (< 600 tokens): Standards document

## Token Budget

**NEVER exceed 2000 tokens per response!**

## Detection Commands

```bash
# Count naming patterns
grep -rE "const [a-z][a-zA-Z]+ =" src/ | wc -l

# Find function patterns
grep -rE "function (get|set|is|has)" src/ | head -20

# Check for any usage
grep -rE ": any" src/ | wc -l