Naming Analyzer
Run a naming-focused pass on variables, functions, classes, and booleans so identifiers read clearly and match language conventions before merge or refactor.
Overview
Naming Analyzer is an agent skill most often used in Ship (also Build backend, Build frontend) that reviews identifier names and proposes clearer, convention-aligned renames.
Install
npx skills add https://github.com/softaworks/agent-toolkit --skill naming-analyzerWhat is this skill?
- Analyzes identifiers for vague, misleading, or inconsistent names against language-specific conventions
- Suggests clearer replacements for functions, classes, variables, and abbreviations
- Calls out boolean naming prefixes and behavior/name mismatches that hide bugs
- Follows an analysis phase across files, directories, or whole codebases with explicit review triggers
- Documented workflow includes a dedicated Analysis Phase for identifiers across files or directories
- Lists five explicit user trigger intents such as analyzing naming, checking conventions, and renaming functions
Adoption & trust: 3.6k installs on skills.sh; 2k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your codebase compiles but names obscure intent, drift across modules, or mislabel what functions actually do.
Who is it for?
Solo developers cleaning up legacy modules, post-feature refactors, or pre-merge sanity checks on public APIs and domain models.
Skip if: Large automated symbol renames across compiled binaries without source, or teams that only need style/format linting with no semantic naming feedback.
When should I use this skill?
Review naming conventions, suggest better variable/function/class names, identify misleading identifiers, or standardize boolean prefixes—e.g. 'Analyze the naming in this file' or 'Check naming conventions in src/'.
What do I get? / Deliverables
You get a structured naming review with concrete rename suggestions that reduce cognitive load and future bug risk.
- Naming issue report with convention gaps
- Suggested replacement identifiers for variables, functions, and classes
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Shelf placement is Ship review because the skill behaves like a specialized reviewer auditing identifier quality and consistency. It targets readability and convention compliance—the same concerns as pre-release code review rather than greenfield scaffolding.
Where it fits
Run a naming pass on the PR diff before merge to catch misleading handler names.
Standardize service and repository method names after an API shape change.
Rename vague event handlers and props in a React or Vue module for agent-generated UI patches.
Audit identifiers in a bug-fix hotspot so the next agent session does not misread state variables.
How it compares
Naming-specific reviewer skill—not a general security audit or test generator.
Common Questions / FAQ
Who is naming-analyzer for?
Developers and agent users who want expert-style feedback on identifier clarity and conventions without a full human code review.
When should I use naming-analyzer?
Use it in Ship → review before merging, during Build while refactoring modules, and in Operate → iterate when renaming reduces confusion in hot paths.
Is naming-analyzer safe to install?
It reads project source to analyze names; review the Security Audits panel on this Prism page and avoid pointing it at secrets-heavy paths you do not want in context.
SKILL.md
READMESKILL.md - Naming Analyzer
# Naming Analyzer Skill A skill for Claude Code that analyzes code naming conventions and suggests better variable, function, class, and other identifier names based on context and industry standards. ## Purpose Good naming is one of the most important aspects of readable, maintainable code. This skill helps developers: - **Identify naming issues** in existing code before they become technical debt - **Improve code clarity** by replacing vague or misleading names with descriptive ones - **Enforce consistency** across a codebase by following language-specific conventions - **Reduce cognitive load** for anyone reading or maintaining the code Poor naming leads to bugs, confusion, and wasted time. This skill acts as an expert code reviewer focused specifically on naming quality. ## When to Use Use this skill when you want to: - Review naming conventions in a file, directory, or entire codebase - Get suggestions for better variable, function, or class names - Check if code follows language-specific naming conventions - Identify misleading names that don't match their actual behavior - Clean up unclear abbreviations or single-letter variables - Standardize boolean naming with proper prefixes **Trigger phrases:** - "Analyze the naming in this file" - "Suggest better names for my variables" - "Check naming conventions in src/" - "Review this code for naming issues" - "Help me rename these functions" ## How It Works 1. **Analysis Phase**: The skill examines all identifiers in the target code: - Variables and constants - Functions and methods - Classes, interfaces, and types - Files and directories - Database tables and columns - API endpoints 2. **Issue Detection**: Each identifier is evaluated for common problems: - Unclear or vague names (`data`, `info`, `temp`, `x`) - Abbreviations that obscure meaning (`usrCfg`, `calcTtl`) - Inconsistent naming conventions (mixing `camelCase` and `snake_case`) - Misleading names (function called `getUser` that also updates data) - Names that are too short or too long - Single-letter variables outside of loop contexts - Missing boolean prefixes (`active` instead of `isActive`) 3. **Convention Checking**: The skill validates against language-specific standards: - JavaScript/TypeScript: camelCase for variables/functions, PascalCase for classes - Python: snake_case for variables/functions, PascalCase for classes - Java: camelCase for variables/methods, PascalCase for classes - Go: PascalCase for exported, camelCase for unexported 4. **Report Generation**: A structured report is produced with: - Summary statistics (items analyzed, issues found by severity) - Critical issues (misleading names that could cause bugs) - Major issues (unclear or vague names) - Minor issues (convention violations) - Specific suggestions with reasoning for each ## Key Features ### Multi-Language Support Understands naming conventions for JavaScript, TypeScript, Python, Java, Go, and more. Automatically adapts recommendations to the language being analyzed. ### Severity Classification Issues are categorized by impact: | Severity | Description | Example | |----------|-------------|---------| | **Critical** | Misleading names that could cause bugs | `getUser()` that also modifies data | | **Major** | Unclear names requiring mental effort to understand | `proc(data)` instead of `processApiResponse(response)` | | **Minor** | Convention violations that affect consistency | `API_url` instead of `API_URL` | ### Boolean Naming Guidance Enforces clear boolean prefixes: - `is` for state: `isActive`, `isVisible`, `isEnabled` - `has` for possession: `hasPermission`, `hasError`, `hasChildren` - `can` for ability: `canEdit`, `canDelete`, `canAccess` - `should` for decisions: `shouldRender`, `shouldValidate`, `shouldRefresh` ### Magic Number Detection Identifies unnamed numeric literals and suggests meaningful constant names: ```javascript // Before i