---

name: naming-conventions description: Fixes naming convention issues including unused variables, single-letter names, and non-standard abbreviations. Use when encountering no-unused-vars errors or reviewing variable naming.

Naming Convention Fixes

Fixes for variable naming issues. Good names are searchable, self-documenting, and follow consistent conventions.

Quick Start

1. Identify the naming issue (unused var, single letter, abbreviation)
2. Determine if the variable is truly needed
3. Apply appropriate fix (rename, remove, or prefix)
4. Verify no regressions

Priority Matrix

---

Workflows

Unused Variables (#5 - 123 occurrences)

Detection: @typescript-eslint/no-unused-vars

Pattern: Variable declared but never used.

Copy// PROBLEM - unused variables
const { data, error, status } = await fetchData();
console.log(data);
// error and status never used

Fix Strategy 1: Underscore prefix (documents intent).

Copy// SOLUTION - underscore prefix
const { data, error: _error, status: _status } = await fetchData();
console.log(data);

Fix Strategy 2: Omit from destructuring.

Copy// SOLUTION - don't destructure unused
const { data } = await fetchData();
console.log(data);

Decision Guide:

Underscore Convention:

• _error - Intentionally ignored
• _unused - Known unused, kept for signature
• _ - Single underscore for completely ignored

---

Single-Letter Variable Names (#19 - 12 occurrences)

Detection: Variable name is single character (except standard exceptions).

Pattern: Short names in array methods.

Copy// PROBLEM - single letters
users.map(u => u.name);
items.filter(i => i.active);
orders.reduce((a, o) => a + o.total, 0);

Fix Strategy: Use descriptive contextual names.

Copy// SOLUTION - descriptive names
users.map(user => user.name);
items.filter(item => item.active);
orders.reduce((sum, order) => sum + order.total, 0);

Acceptable Single Letters:

Naming Patterns:

Reduce Accumulator Names:

---

Non-Standard Abbreviations (#30 - 15 occurrences)

Detection: Project-specific abbreviations that aren't universally understood.

Pattern: Abbreviated variable names.

Copy// PROBLEM - non-standard abbreviations
const cwd = process.cwd();
const dir = path.dirname(file);
const env = process.env.NODE_ENV;
const cfg = loadConfig();

Fix Strategy: Expand non-standard, keep standard.

Copy// SOLUTION
const currentWorkingDirectory = process.cwd();
const directory = path.dirname(file);
const environment = process.env.NODE_ENV;
const config = loadConfig();

// KEEP (universally understood)
const url = new URL(input);
const userId = params.id;
const apiKey = env.API_KEY;

Standard Abbreviations (KEEP):

Non-Standard Abbreviations (EXPAND):

Exception: Framework/library conventions (e.g., Express req/res).

---

Unused Destructuring Pattern (#29 - 1 occurrence)

Pattern: Rest element captures unused properties.

Copy// PROBLEM - rest captures unused
const { used, ...rest } = object;
// rest never used

Fix Strategy: Remove rest or use it.

Copy// SOLUTION - just destructure what's needed
const { used } = object;

// OR - if you need to exclude properties
const { excluded: _excluded, ...rest } = object;
passToFunction(rest);

---

Scripts

Check Naming Issues

Copynode scripts/check-naming.js /path/to/src

Find Single-Letter Variables

Copynode scripts/find-short-names.js /path/to/file.ts

---

ESLint Configuration

Unused Variables Rule

Copy// eslint.config.js
{
  rules: {
    '@typescript-eslint/no-unused-vars': ['error', {
      argsIgnorePattern: '^_',
      varsIgnorePattern: '^_',
      caughtErrorsIgnorePattern: '^_',
      destructuredArrayIgnorePattern: '^_',
    }],
  },
}

Naming Convention Rule

Copy{
  rules: {
    '@typescript-eslint/naming-convention': [
      'error',
      // Variables: camelCase
      {
        selector: 'variable',
        format: ['camelCase', 'UPPER_CASE'],
        leadingUnderscore: 'allow',
      },
      // Functions: camelCase
      {
        selector: 'function',
        format: ['camelCase'],
      },
      // Types/Interfaces: PascalCase
      {
        selector: 'typeLike',
        format: ['PascalCase'],
      },
      // Constants: UPPER_CASE or camelCase
      {
        selector: 'variable',
        modifiers: ['const'],
        format: ['camelCase', 'UPPER_CASE'],
      },
    ],
  },
}

---

Naming Best Practices

Be Specific

Copy// BAD
const data = fetchData();
const result = process(data);
const value = calculate(result);

// GOOD
const userProfile = fetchUserProfile();
const validatedProfile = validateProfile(userProfile);
const profileScore = calculateProfileScore(validatedProfile);

Use Verb Prefixes for Booleans

Copy// BAD
const visible = true;
const admin = user.role === 'admin';

// GOOD
const isVisible = true;
const isAdmin = user.role === 'admin';
const hasPermission = checkPermission(user);
const canEdit = isAdmin && hasPermission;

Use Verb Prefixes for Functions

Copy// BAD
const user = async (id) => { ... };
const validation = (input) => { ... };

// GOOD
const getUser = async (id) => { ... };
const validateInput = (input) => { ... };
const createOrder = (items) => { ... };
const updateProfile = (data) => { ... };
const deleteRecord = (id) => { ... };

Avoid Redundant Context

Copy// BAD (in User class)
class User {
  userName: string;
  userEmail: string;
  getUserAge(): number;
}

// GOOD
class User {
  name: string;
  email: string;
  getAge(): number;
}

Collection Naming

Copy// Plural for collections
const users: User[] = [];
const orderMap: Map<string, Order> = new Map();
const productIds: Set<string> = new Set();

// Singular for single items
const user = users[0];
const order = orderMap.get(id);