Przejdź do treści
Biblioteka skilli
Programowanie · Integracja z narzędziem

vale

/vale

Prowadzi przez linting prozy w Vale: jedenaście punktów rozszerzeń, zakresy w .vale.ini i globy sekcji, redukcja alertów oraz komentarze wyłączające, przy pisaniu reguł stylu i diagnozie fałszywych alarmów.

Repozytorium
claude-skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
07.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
4
Skrypty
0
Komentarze HTML
2
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 07.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • SKILL.md zawiera komentarze HTML (2). Nie widać ich w podglądzie Markdown, a model je czyta.

Co robi i kiedy

Prowadzi przez linting prozy w Vale: jedenaście punktów rozszerzeń, zakresy w .vale.ini i globy sekcji, redukcja alertów oraz komentarze wyłączające, przy pisaniu reguł stylu i diagnozie fałszywych alarmów.

Oryginalny opis (EN)

Guide for Vale prose linting — the eleven extension points, .vale.ini scoping and section globs, alert-level burn-down, and suppression comments. Use when authoring or editing a Vale style rule, debugging a prose-lint false positive, or choosing which extension point fits a new rule. Use when wiring a section glob in .vale.ini or scoping a rule to one frontmatter field.

Jak działa

  1. When to reach for it
  2. Install and pin
  3. The eleven extension points
  4. Scopes
  5. Alert levels — the burn-down mechanism
  6. .vale.ini structure and section globs
  7. Suppression
  8. Running it
  9. Anti-fabrication
  10. References
Sekcje z nagłówków SKILL.md, w oryginale · 107 linii, 1 181 słów
Podgląd SKILL.md
---
name: vale
description: Guide for Vale prose linting — the eleven extension points, .vale.ini scoping and section globs, alert-level burn-down, and suppression comments. Use when authoring or editing a Vale style rule, debugging a prose-lint false positive, or choosing which extension point fits a new rule. Use when wiring a section glob in .vale.ini or scoping a rule to one frontmatter field.
license: MIT
---

# Vale

Vale is a command-line prose linter. It applies declarative YAML rules to Markdown, checking word choice, sentence shape, and terminology. It works the way a compiler checks syntax — deterministically, on every run, without a human rereading the diff.

## When to reach for it

Reach for Vale when a team wants a style rule enforced in CI, not just repeated in review comments. Typical rules: banned words, hedged directives, sentence-length caps, terminology consistency, passive-voice detection. A rule written once as a Vale style runs on every PR. A rule stated only in a CLAUDE.md runs only when a reviewer remembers it.

## Install and pin

```toml
# mise.toml
[tools]
vale = "3.18.0"
```

```bash
mise install
mise exec -- vale --version   # vale version 3.18.0
```

`vale` is a mise registry short name; the pin needs no backend prefix. It resolves to `aqua:vale-cli/vale` — confirm with `mise registry | grep '^vale'`.

Pin the exact version, not `latest`. Rule semantics shift between Vale minor releases — a new default, a changed regex engine, an added extension point. An unpinned `latest` lets CI absorb that drift silently. A pinned version fails loudly on `mise install` instead, at the moment someone chooses to bump it.

## The eleven extension points

Every Vale rule extends exactly one of these. Pick the point by what the rule needs to see, not by habit.

| Extension | Fits |
|---|---|
| `existence` | Flag a fixed list of banned or watched tokens |
| `substitution` | Flag a token and suggest its replacement |
| `occurrence` | Cap how many times a pattern appears in a scope |
| `repetition` | Catch an immediate word repeated back to back |
| `consistency` | Force one spelling of a term across the whole document set |
| `conditional` | Require a second pattern wherever a first pattern appears |
| `capitalization` | Enforce a heading or title case convention |
| `metric` | Gate on a computed formula, such as a readability score |
| `spelling` | Check against a dictionary, with custom word lists |
| `sequence` | Match a sequence of tokens by part-of-speech tag |
| `script` | Run a custom Tengo script for logic no built-in extension covers |

`sequence` is the one extension able to see grammar, not just characters. It matches part-of-speech tags — a verb, a determiner, a past participle. That is what lets it catch passive voice ("the file was deleted") without flagging every unrelated use of the word was. A regex-based `existence` rule only sees text, not grammar.

## Scopes

A rule's `scope` field controls what part of the document it reads. The default scope is the whole raw file, and that includes YAML frontmatter. A plain `existence` rule with no `scope` set flags a banned word inside a `description:` field exactly as it would flag one in the body.

`text.frontmatter.<field>` narrows a rule to one named frontmatter field only, ignoring the body and every other field. Use it for a check that only makes sense on one field, such as a length cap on a skill's `description`. It does not also cap every heading in the file.

Fenced code blocks are skipped by default under the standard Markdown scope. A rule that must reach inside a fence needs an explicit `scope: raw`.

## Alert levels — the burn-down mechanism

Each rule sets a `level` of `suggestion`, `warning`, or `error`. Only `error` findings make `vale`'s process exit non-zero. `warning` and `suggestion` findings print but never fail a run.

That gap is the intended mechanism, not a defect to close immediately. Ship a new rule at `warning` while its findings burn down across the existing corpus. Promote it to `error` once the count reaches zero. A rule that lands at `error` on day one either fails every open PR at once, or gets disabled outright.

## `.vale.ini` structure and section globs

```ini
StylesPath = styles
MinAlertLevel = warning

[*.md]
BasedOnStyles = Flavored

[plugins/*/agents/*.md]
BasedOnStyles = Flavored, Strict
```

`StylesPath` points at the directory holding one subdirectory per style — `Strict/` and `Flavored/` here. Each `[glob]` section maps a path pattern to the styles active for matching files.

**Verified**: two sections with **different** globs do not merge. When a file matches both, the **last matching section wins wholesale** — not the most specific one. A third overlapping section does not change that; the last one still wins. Repeating the **same** glob string is the one exception: those styles accumulate. Two style sets in separate sections gave a deeper file only the later section's findings. Flipping the section order flipped which one applied. So a section that lists one style silently drops every other style from those files. That is why this repo's strict sections list `Flavored, Strict` rather than `Strict` alone.

**Verified**: a `*` in a Vale section glob crosses `/`. `plugins/*/agents/*.md` matches both `plugins/aaa/agents/x.md` and a file three levels deeper, `plugins/aaa/bbb/ccc/agents/x.md`. Fixtures at each depth, tested directly against the Vale binary, both flagged by the same section. A second, more specific pattern written to catch deeper nesting is dead configuration — the shallow glob already covers it.

## Suppression

```markdown
<!-- vale Flavored.Clutter = NO -->
"In order to" means "to." "At this point in time" means "now."
<!-- vale Flavored.Clutter = YES -->
```

Suppress a rule only where there is nothing to fix. The most common case is a document that teaches the rule by naming the exact words it bans. A banned-word list trips its own rule on every listed example, and so does a clutter-phrase table. That is correct, not a bug — rewriting the examples to dodge the linter would make them useless as examples. Reach for suppression there, never as a shortcut past a real finding elsewhere in the same file.

## Running it

```bash
mise run test:prose
```

The task runs `vale` once to print every finding at any level. It runs `vale` a second time, with `--minAlertLevel error`, to decide the gate. Piping either run to `| ignore` in Nushell discards the exit code along with the output. Verified: `nu -c '^false | ignore; print "reached"'` prints and still exits `0`. The shipped task avoids this trap. It captures the second run with `complete` and re-raises `$gate.exit_code` itself, so a real error finding still fails the build.

## Anti-fabrication

Every claim this skill makes about Vale's behavior comes from running the Vale binary against a fixture and reading its output. It does not come from documentation alone, or from memory. A reference claim can stay undemonstrated when no fixture ran against that extension point. The note there says so, rather than claiming the syntax as tested. Follow `/core:anti-fabrication` for the full rule set this inherits.

## References

- [references/extension-points.md](references/extension-points.md) — a worked YAML example for each of the eleven extension points
- [references/rule-authoring.md](references/rule-authoring.md) — the false-positive discipline, scoping a new rule, and testing it before it ships
- [references/repo-setup.md](references/repo-setup.md) — how this repo wires the pin, `.vale.ini`, the two style directories, the mise task, and CI end to end
Pliki w paczce (4)
  • SKILL.md 8 KB
  • references/extension-points.md 6 KB
  • references/repo-setup.md 6 KB
  • references/rule-authoring.md 4 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · vinnie357/claude-skills100MIT
jscraik/Agent-Skills100Apache-2.0
htlin222/dotfiles100MIT

Migawka bazy z 13.11.2026 · wersja paczki 764555709b46 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100setup
    Instaluje Vale, tworzy plik .vale.ini, synchronizuje style i uruchamia pierwsze sprawdzenie języka w dokumentacji.
  • 100triage
    Pomaga przejść od pierwszego dużego przebiegu Vale do decyzji dla każdej reguły: poprawić, obniżyć lub wyłączyć.
  • 100authoring-documentation
    Prowadzi przez pisanie plików dokumentacji: szablony 11ty, shortcody Eleventy, adnotacje JSDoc i Markdown, z obsługą błędów lintera Vale, słownika i frontmatter.
  • 100docs-review
    Sprawdza i poprawia dokumentację Mintlify według przewodnika stylu, w diffach i pull requestach, także zasady, których nie sprawdzi Vale.
  • 100documentation-validation
    Waliduje jakość dokumentacji: linting prozy z Vale, składnia Markdown i RST, sprawdzanie linków, testy przykładów kodu, walidacja notebooków i instrukcji instalacji oraz CI dla testów dokumentacji.
  • 100zeabur-writing
    Pisze i sprawdza teksty w repozytoriach zeabur-oss po angielsku, chińsku tradycyjnym i uproszczonym, z kontrolą stylu Vale.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.