Write Coding Standards From File

An AI skill that analyzes existing code files and generates coding standards documentation by extracting patterns, conventions, and practices already established in the codebase, creating team guidelines that reflect how the code is actually written.

What Is This?

Overview

This skill reads source code files and infers the coding standards being followed. It identifies naming conventions, formatting patterns, error handling approaches, and architectural patterns. The output captures what the team is already doing, making implicit conventions explicit.

Who Should Use This

Perfect for teams that have established conventions through practice but never documented them, new team leads inheriting codebases without style guides, and organizations needing to formalize standards for compliance without disrupting existing workflows.

Why Use It?

Problems It Solves

Many teams write code consistently but have no written standards. When new developers join, they learn conventions through osmosis and code review feedback, which is slow and inconsistent. Writing standards from scratch is time consuming and often produces idealistic rules that do not match reality. This skill generates standards that reflect actual practice.

Core Highlights

• Pattern Extraction identifies conventions from existing source code
• Multi File Analysis cross-references patterns across many files for consistency
• Convention Categories organizes findings into naming, formatting, structure, and patterns
• Example Inclusion includes real code examples from the codebase as references
• Deviation Detection flags areas where the codebase is inconsistent with itself

How to Use It?

Basic Usage

Point the skill at your source files and it generates a standards document.

## Generated Coding Standards

### Naming Conventions
- **Variables**: camelCase (found in 98% of files)
- **Functions**: camelCase (consistent across all files)
- **Classes**: PascalCase (consistent across all files)
- **Constants**: UPPER_SNAKE_CASE (found in 94% of files)
- **Files**: kebab-case.ts (found in 87% of files)
  - Deviation: 13% of files use camelCase naming

### Import Ordering
1. External packages (node_modules)
2. Internal aliases (@/components, @/utils)
3. Relative imports (./local)
4. Style imports (.css, .scss)

Real-World Examples

Legacy Codebase Documentation

A team of 20 developers inherited a 5-year-old Python codebase with no style guide. The skill analyzed 400 Python files and produced a comprehensive standards document covering docstring format, exception handling patterns, import style, class organization, and test structure. It also identified 12 areas where the codebase was inconsistent with itself.

def get_user(user_id: str) -> User:
    try:
        user = user_repo.find(user_id)
        if user is None:
            raise UserNotFoundError(f"User {user_id} not found")
        return user
    except DatabaseError as e:
        logger.error(f"Database error fetching user: {e}")
        raise ServiceError("Failed to retrieve user") from e

Advanced Tips

Run the analysis on recent files weighted more heavily than old files since conventions evolve. Use the deviation report to prioritize cleanup tasks for areas where the codebase disagrees with itself. Re-run quarterly to capture evolving conventions.

When to Use It?

Use Cases

• Team Onboarding give new developers a written guide matching actual practices
• Standards Formalization document existing conventions for compliance purposes
• Code Consistency identify areas where the codebase contradicts itself
• Linter Configuration derive linting rules from observed patterns
• Merge Preparation align conventions before merging codebases

Related Topics

When generating coding standards, these prompts activate the skill:

• "Generate coding standards from my codebase"
• "Extract conventions from these source files"
• "Document the patterns used in this project"
• "Create a style guide based on existing code"

Important Notes

Requirements

• Source code files in a supported language for analysis
• Multiple files recommended for more accurate pattern detection
• Recent, actively maintained code produces more relevant standards
• Works with any programming language that has identifiable conventions

Usage Recommendations

Do:

• Review generated standards with the team before adopting them officially
• Address flagged deviations to improve codebase consistency over time
• Update standards periodically as conventions evolve through practice
• Include code examples from the actual codebase in the final document

Don't:

• Accept minority patterns as standards when the majority follows a different convention
• Force consistency where variation is intentional like different patterns for different layers
• Skip team review since some observed patterns may be accidental rather than intentional
• Generate from stale code as outdated files may reflect abandoned conventions

Limitations

• Cannot determine intent behind patterns, only that they are consistently used
• Small codebases may not have enough files for reliable pattern detection
• Generated standards reflect current practice which may include anti-patterns
• Cannot detect conventions that exist only in team knowledge and not in code