Skip to content
Skills Library
Programming · Planning

naming

/naming

Naming rules for files, custom element tags, skills, functions, and CSS custom properties. Names describe the concern, not the implementation, so they survive refactors. Use whenever creating any new named thing or renaming an existing one.

Repository
ai ↗
Licence
MIT
Last repository change
04.09.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
4
Deprecation

No signals detected. Repository changed on 04.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Naming rules for files, custom element tags, skills, functions, and CSS custom properties. Names describe the concern, not the implementation, so they survive refactors. Use whenever creating any new named thing or renaming an existing one.

Original author description

Naming rules for files, custom element tags, skills, functions, and CSS custom properties. Names describe the concern, not the implementation, so they survive refactors. Use whenever creating any new named thing or renaming an existing one.

How it works

  1. Files
  2. Custom element tags
  3. toTagName, not toKebab
  4. Skills
  5. Functions
  6. CSS custom properties
  7. Cross-file references
  8. What naming never does
  9. Baseline & support
  10. References
Original SKILL.md headings · 132 lines, 659 words
SKILL.md preview
---
name: naming
description: Naming rules for files, custom element tags, skills, functions, and CSS custom properties. Names describe the concern, not the implementation, so they survive refactors. Use whenever creating any new named thing or renaming an existing one.
license: MIT
metadata:
  version: "1.0.0"
---

# Naming

Names describe the **concern**, not the **current implementation**. A name should survive any internal change to how the thing works.

Good: `layout`, `transitions`, `state-machines`, `themes`
Bad: `holy-grail-layout`, `oklch-themes`, `radio-checkbox-state-machines`

If the implementation changes from oklch to OkLab, the name `themes` still describes the concern. The name `oklch-themes` would lie.

## Files

### Active vs. inactive

- **Active files** have no trailing underscore: `layout.css`, `themes.css`, `app.js`.
- **Inactive files** (preserved for reference but not loaded by the runtime) have one or more trailing underscores: `typography_.css`, `typography__.css`, `fonts_.css`. Multiple underscores indicate older inactive versions.

The trailing-underscore convention is a build-tool-free way to mark a file as not part of the active runtime while keeping it visible in the directory.

### File-name describes concern

| Concern | File |
|---|---|
| Reset rules | `reset.css` |
| Layout | `layout.css` |
| Typography | `typography.css` |
| Themes | `themes.css` |
| API transport | `api.js` |
| `oninput` lifecycle | `oninput.js` |
| Storage | `storage.js` |

Not:

| Bad | Why |
|---|---|
| `holy-grail.css` | Implementation, not concern |
| `dark-mode.css` | Half the concern (themes covers light + dark) |
| `fetch-utils.js` | Implementation; `api.js` is the concern |

## Custom element tags

Custom elements must contain a hyphen (HTML spec). Tag names describe the role:

- `app-container` — the layout root
- `app-logo` — the brand mark slot
- `app-user` — the user-info slot
- `app-legal` — the legal-text slot
- `app-version` — the version-display slot
- `app-banner` — optional notification slot

For data-rendered elements, see the `data-flow` skill — `toTagName(key)` produces the tag from a JSON key.

## `toTagName`, not `toKebab`

The function is named for what it does (produces a valid HTML tag name), not for the case style it happens to use. If the spec ever permitted other separators, the function name still describes the concern.

## Skills

Skills follow the same rule. Skill names describe the concern:

- `html` (concern: structural markup), not `semantic-html` (concerns and adjectives stack)
- `css` (concern: UI runtime), not `modern-css`
- `state-machines` (concern: how interactivity is encoded), not `checkbox-radio-pattern`

Standard requires lowercase letters, numbers, and hyphens only. No underscores in skill names. The skill directory name must match the `name` field in the YAML frontmatter.

## Functions

Function names describe what the function does, in verb form:

- `fetchJSON(url)` — fetches and returns JSON
- `toTagName(key)` — converts a key to a tag name
- `clearFieldset(el)` — clears a fieldset

Not:

- `helper()`, `process()`, `handle()` — vague
- `oklchHelper()` — implementation in the name

## CSS custom properties

CSS custom property names use double-hyphen prefix (CSS spec), then describe the concern:

- `--surface-1`, `--surface-2`, `--surface-3` — semantic surface levels
- `--text-1`, `--text-2` — semantic text levels
- `--accent` — the brand accent
- `--transition-duration`, `--transition-property`, `--transition-timing-function`

Not:

- `--blue-500`, `--red-700` — color name in the variable; if the brand changes, the name lies
- `--my-special-color` — vague

## Cross-file references

Cross-file references in documentation are **text references**, not symlinks. Always:

```markdown
See `references/state-machines.md` for the canonical pattern.
```

Never:

```
references/state-machines.md → ../html/references/state-machines.md   (symlink)
```

Reasoning: text references are visible in any file viewer, survive copy/paste, and produce no surprise file system behavior. Symlinks are invisible context that breaks portability.

## What naming never does

- Never names by implementation detail
- Never names by adjective stack (`modern-`, `semantic-`, `accessible-`)
- Never embeds a value in a name (`--color-blue` is bad; the value is `oklch(...)`, the concern is "brand")
- Never uses ambiguous names (`utils.js`, `helper()`, `data`)
- Never relies on symlinks for cross-file references

## Baseline & support

_Checked against MDN as of 2026-07-16._

- No version-sensitive web-platform features are referenced here — everything used is **Baseline Widely available**.

**Canonical rules:** https://github.com/Autocss-com/ai/blob/main/AGENTS.md

## References

- `references/examples.md` — concrete good and bad examples for each named-thing kind
- HTML custom elements naming rules: https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
- CSS custom properties spec: https://www.w3.org/TR/css-variables-1/
- Agent Skills naming spec: https://agentskills.io/specification#name-field
Files in this package (2)
  • SKILL.md 5 KB
  • references/examples.md 4 KB

Versions

RepositoryScoreLicence
This page · autocss-com/ai100MIT
ciro-maciel/ccm-stack100MIT
cofoundy/brand-skills100MIT
juztripper/already-looked100MIT
hanamizuki/solopreneur95MIT
hanamizuki/solopreneur95MIT
Esposter/Esposter90Apache-2.0

Database snapshot: 13.11.2026 · package version d28dea445415 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100design-api
    Design a custom element's public API e.g. attributes, properties, events, slots, CSS parts and custom properties. Use when the user asks to "design an element", "plan a component API", "create element API", "design component interface", or discusses naming conventions, API…
  • 100naming-convention
    Structured naming convention system for code identifiers. Use when naming or renaming variables, functions, methods, classes, files, DB tables/columns, routes, or CSS classes; when validating identifiers against a convention; or when the user mentions naming, camelCase,…
  • 100naming-analyzer
    Suggest better variable, function, and class names based on context and conventions. Use only when the user explicitly asks "what should I call this", "better name for", "rename this", "naming suggestion", or explicitly requests a naming review.
  • 90naming-things
    Choose names that carry meaning so readers grasp intent without chasing definitions. Use when naming variables, functions, types, or files, or when a name reads as vague.
  • 90go-naming
    Use when naming Go packages, types, functions, methods, variables, constants, or receiver names, including new types and exported APIs. Package organization belongs to go-packages.
  • 90principle-clear-naming
    Apply when naming variables, functions, types, files, or endpoints. Enforces the 6-month amnesia test, language conventions, intent-based naming, and cross-boundary consistency.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.