tokio-rs/tokio

Why this matters

tokio is the inverse of the Kubernetes shape — there is no ci/ directory, no hack/verify-*.sh pipeline, no custom linter binary. All structural validation lives in 7 GitHub Actions workflows (~1714 lines total), with the bulk in one ~1365-line ci.yml driving a multi-OS / multi-target / multi-feature matrix. That matrix is mostly build-and-test jobs (out of alint’s “no-build / no-execute” scope), but it carries roughly 12 distinct repo-state checks woven into the fmt, clippy, docs, semver, check-readme, and check-spelling jobs, plus the two cargo-deny workflows.

This is the canonical “convention without checks” case study — the cleanest demonstration in the catalogue of how a well-tooled Rust workspace silently relies on conventions its CI pipeline assumes but doesn’t explicitly verify. Use it as the launch counterpoint to kubernetes.

Headline catch

Kubernetes has 50 hand-rolled shell scripts; alint replaces 17 of them with one declarative config. tokio has zero hand-rolled shell scripts — all its structural validation lives in matrix-driven CI workflows that implicitly rely on the repo being sane. alint catches the 15 conventions tokio’s pipeline assumes but doesn’t explicitly verify.

The pitch lands as defense-in-depth, not replacement. tokio’s CI is already excellent; alint adds a layer that runs before CI — at keystroke time in an editor (with the JSON Schema), at pre-commit time (the bundled validate-config subcommand), or at the front of the pipeline. The conventions that previously lived only as oral history become checked, version-controlled, and diff-reviewable.

The 15 silent conventions tokio relies on (none surfaced by existing tools):

• internal crates declare publish = false (benches, examples, stress-test, tests-build, tests-integration)
• the 5 published tokio-* crates declare license = "MIT"
• every member’s Cargo.toml has [lints] workspace = true so the workspace’s unexpected_cfgs allowlist propagates
• deny.toml exists, has a non-empty [licenses].allow[*], and bans wildcards
• workspace root has [patch.crates-io] tokio = { path = "tokio" }
• the canonical workflow / config files exist (catches accidental deletions before next merge)
• spellcheck.dic first line is the integer line-count header
• …and 8 more along the same shape

Each is a regression class that’s currently caught only when CI mysteriously breaks downstream.

Where alint earns its keep here

• The 6 mappable per-tool checks (fmt / clippy / deny / doc / semver / spellcheck) wrap into one command: rule each — alint isn’t faster than cargo lint itself, but running them all in parallel under one alint check shaves wall time vs. the sequential pre-push chain.
• The 15 silent conventions become declarative. Each is 3-5 lines of YAML; the whole layer is ~80 lines and runs in well under a second on tokio’s tree.
• check-readme (the diff README.md tokio/README.md cross-file equality) is canonical demand for v0.10 cross_file_value_equals — joining airflow + clap + uv + react
  • pnpm + pytorch + tensorflow as the 8th saturated source. Past saturation; v0.10 must-ship.
• spellcheck.dic sortedness is canonical demand for v0.10 ordered_block — joining rust-lang/rust + 3 more as the rule kind ships in v0.10.
• The pitfall #16 cross-reference (JSONPath bool/number regex coercion) was discovered in next.js and is silently relevant to tokio’s stringified-bool-match patterns; the case study notes a CONFIG-AUTHORING.md cross-reference candidate.

Future story angles

• Launch tile candidate — position as the “well-tooled Rust workspace + zero hand-rolled scripts” data point alongside kubernetes (50 hand-rolled scripts) and rust-lang/rust (one custom linter binary). The contrast spans the full design space: kubernetes script sprawl ↔ rust-lang custom binary ↔ tokio matrix CI — and alint sits underneath all three.
• “Defense-in-depth” launch narrative — tokio’s framing (the conventions assumed but never checked) generalises beyond Rust. Every well-tooled monorepo accumulates conventions enforced only by review etiquette; alint is the layer that promotes them to checked artefacts. The pitch lands cleanly on JS / Go / Python monorepos with similar discipline (kubernetes’ OWNERS files, next.js’s husky pre-push protection, react’s codes.json registry).
• Saturation-evidence narrative — tokio’s gap catalogue overlaps heavily with what kubernetes and rust-lang/rust already surfaced. The overlap itself is useful evidence that the v0.10+ rule-kind pipeline is saturating — the same gaps keep recurring across case studies, which is the launch-evidence shape we want for shipping the v0.10 set with confidence.