standards git:20260903.10f0277A

Immutable. This exact content is served forever at /api/v1/blob/3baaa2088696393a.

---
name: standards
description: 'Load only the standards relevant to a caller-supplied change, then report concrete findings. Triggers: "check standards", "which standards apply".'
practices:
- pragmatic-programmer
- clean-code
hexagonal_role: supporting
consumes: []
produces:
- stdout
context_rel: []
skill_api_version: 1
metadata:
  capabilities: [standards]
  effects: []
  canonical_status: canonical
  disposition: keep_specialist
  tier: knowledge
  dependencies: []
output_contract: cited standards and factual findings
---
# Standards — focused engineering guidance

Load the smallest set of standards justified by the caller's files, language,
and risks. Do not preload the entire reference corpus.

## Prompt

```text
Check standards for the changed files in fleet-router PR #214: cli/internal/auth/token.go and cli/internal/auth/token_test.go, Go, a security-sensitive change. Load only the matching references and report cited findings with path and line plus checked and not-checked scope.
```

## It's working if

- The report loads `common-standards.md` plus only the matching Go reference, never the full reference corpus.
- Every finding cites a path and line, e.g. `cli/internal/auth/token.go:18`.
- The response discloses `checked` and `not_checked` scope explicitly, even when `not_checked` is empty.
- `git diff --stat` shows no test, gate, or fixture file changed; standards reports findings only.

## Procedure

1. Record the supplied paths, language, change type, and risk cues.
2. Load `common-standards.md` plus only the matching language or checklist
   references.
3. Compare the supplied artifact to those sources.
4. Return cited findings with path and line when possible, plus checked and
   not-checked scope.
5. Stop.

This skill provides context and findings. It does not edit, validate, retry,
approve, commit, release, deliver, or decide continuation.

## Load-bearing conventions for produced code (MEASURED)

When the caller is about to WRITE code (not only review it), surface the
matching language rules INLINE in the working context — a behind-the-link
reference does not change behavior; an inline imperative does. The Go core:

- Wrap every propagated error with context: `fmt.Errorf("doing X: %w", err)`
  — never return a bare inner error.
- Multi-case functions get TABLE-DRIVEN tests (`[]struct` cases + `t.Run` per
  case), asserting exact expected values including the error cases.

For other languages, pull the matching reference below and inline its top
rules the same way.

> Measured 2026-08-04, probe `standards-go-conventions` (gpt-5.6-luna, N=2,
> directional): control produced the `%w`-wrapped + table-driven shape in 1/2
> runs; with these rules inline, 2/2. Inline-imperative beats reference-link —
> the graphify probe measured a linked doc instruction obeyed 0/2. Ledger:
> `evals/skill-probes/LEDGER.md`.

## Mutation-safety standards

When the supplied change rewrites existing files in bulk — formatters,
codemods, migration scripts, generators pointed at hand-written sources —
check it against three standards and report each as a finding when absent:

- **Single audited mutation chokepoint.** All rewrites flow through one named
  command or script whose inputs, outputs, and dry-run mode can be inspected.
  Edits scattered across ad-hoc one-liners and manual touch-ups are the
  **diffuse mutation** failure mode: no single point can be audited, re-run,
  or blamed. Finding: name every mutation path outside the chokepoint.
- **Hash-witnessed backups before rewrite.** Before the chokepoint runs, the
  originals are preserved with content hashes recorded (a committed baseline
  counts), so "the rewrite changed only what it claims" is checkable
  byte-for-byte, not asserted. Finding: a bulk rewrite with no verifiable
  before-state.
- **Self-administered ambition gate.** The change states what it deliberately
  does not touch, and the diff respects it. A formatter run that also renames,
  a codemod that also refactors, is the **scope-creep rewrite** failure mode.
  Finding: any file class in the diff outside the change's own stated scope.

Stop condition for this check: all three standards have an explicit pass or
finding; a bulk-rewrite review that reports style nits but skips these is
incomplete.

## References

- [Common standards](references/common-standards.md)
- [Go](references/go.md)
- [Python](references/python.md)
- [Rust](references/rust.md)
- [TypeScript](references/typescript.md)
- [JavaScript](references/javascript.md)
- [Shell](references/shell.md)
- [JSON](references/json.md)
- [YAML](references/yaml.md)
- [Markdown](references/markdown.md)
- [SQL safety](references/sql-safety-checklist.md)
- [Race conditions](references/race-condition-checklist.md)
- [LLM trust boundaries](references/llm-trust-boundary-checklist.md)
- [Skill structure](references/skill-structure.md)
- [Test strategy](references/test-pyramid.md)