Woodpile Quest

Tracks

1. 01🪵Why Own Weights

   0/5 lessons

   The link is a loan — and loans get called in

   Before any tool or command, the woodpile needs a reason. This track is the argument: model weights are among the few digital artifacts that can be truly owned, yet almost everyone interacts with them as tenants — through links, through hosted endpoints, through runtimes that re-download whatever the provider currently serves. Weights disappear in three documented ways (deletion, policy, and company death), the preservation horizon is measured in years not sprints, and the strongest reason to stack wood is one nobody markets: one day you may need to build from materials you already hold. The track closes with the discipline that separates a woodpile from a hoard.

   Lesson list (5)

   • 01
     The Link Is a Loan~12 min · preservation, availability, risk
   • 02
     What Owning Actually Means~13 min · ownership, digest, license, offline
   • 03
     The Preservation Horizon~12 min · preservation, time-horizon, versioning, research
   • 04
     The Vessel Argument~12 min · future-use, fine-tuning, distillation, sovereignty
   • 05
     A Woodpile, Not a Museum~11 min · curation, acquisition-policy, fidelity, philosophy

   ✓Quiz · 5 questions→

2. 02🧬Reading Artifacts

   0/6 lessons

   The material science of model files — formats, dtypes, and variant trees

   An archivist who cannot read the object acquires blind. This track is the literacy layer: what a model repository actually contains beyond the marketing page, why safetensors displaced pickle-based formats and what that buys beyond speed, how GGUF structures a quantized artifact and what each rung of the quantization ladder costs, and the single most load-bearing skill in the whole quest — reading dtype claims as evidence rather than verdicts, because a BF16 label may be a native representation, a real derivative, or a padded upcast of something lossier. Sharded files, revision trees, and the provenance signals hidden in commit history close the track.

   Lesson list (6)

   • 01
     Anatomy of a Model Repository~13 min · hugging-face, repository-structure, config, files
   • 02
     Safetensors, and Why It Won~13 min · safetensors, pickle, security, format
   • 03
     GGUF and the Quantization Ladder~14 min · gguf, quantization, llama-cpp, tradeoffs
   • 04
     Reading Dtype Like an Archivist~14 min · dtype, bfloat16, fp8, upcast, evidence
   • 05
     Variant Trees and Revision Pins~12 min · revisions, branches, sharding, pinning, git
   • 06
     Provenance Signals~12 min · provenance, commit-history, model-card, chain-of-custody

   ✓Quiz · 5 questions→

3. 03🕵️Sourcing Truth

   0/5 lessons

   Maker or mirror — judging where an artifact really comes from

   Track two taught you to read what a repository contains and what signals its files carry; this track teaches you to judge who is speaking. The open-weight ecosystem has more mirrors than makers: re-uploads, refreshed copies, quietly quantized re-releases wearing original names, and fine-tunes that forget to mention their base. You will learn to identify the authoritative publisher, autopsy a model card for the claims that matter, treat licenses as part of the artifact rather than paperwork, run the dtype trap as a practical decision procedure, and recognize the tells that say walk away. This is the review desk of the archive: nothing acquires without passing it.

   Lesson list (5)

   • 01
     Maker or Mirror~12 min · provenance, publisher, mirror, identity
   • 02
     Reading a Model Card Forensically~13 min · model-card, metadata, verification, claims
   • 03
     Licenses Are Part of the Artifact~12 min · license, apache-2.0, llama, terms, compliance
   • 04
     The Dtype Trap, in Practice~13 min · dtype, decision, case-study, acquisition
   • 05
     When to Walk Away~11 min · walk-away, red-flags, discipline, curation

   ✓Quiz · 5 questions→

4. 04🔐Integrity

   0/6 lessons

   Digests, transfers, and proof that your bytes are your bytes

   Ownership's second condition — digest verified — becomes this track's craft. SHA-256 as the contract a file makes with its identity; LFS pointer files and where hubs actually publish the digests you check against; acquisition with the official CLI (auth, patterns, rate limits); resumable transfers as the survival trait of large-file work (.part files, HTTP ranges); post-landing verification that catches the corruption a clean exit code hides; and finally the trust chain — the ordered list of things you believe about one file, from URL to bytes to storage, and what each belief costs.

   Lesson list (6)

   • 01
     The Digest Contract~12 min · sha256, checksum, integrity, verification
   • 02
     LFS Pointers and Hub Digests~12 min · git-lfs, pointer-file, etag, reference-digest
   • 03
     Downloading with the HF CLI~13 min · huggingface-cli, hf-download, auth, patterns
   • 04
     Resumable Transfers~12 min · resume, range-requests, part-files, large-files
   • 05
     Verify After Landing~11 min · verification, corruption, bit-rot, health
   • 06
     Trust Chains for One File~11 min · trust, provenance, synthesis, model

   ✓Quiz · 5 questions→

5. 05🏚️Archive Design

   0/5 lessons

   Storage, layout, pacing, and records — building the shed the wood lives in

   Bytes verified are bytes housed — but where they live decides whether they outlive you caring about them. This track is the architecture of the shed: storage layers that survive individual disk deaths (local, network, the 3-2-1 posture); naming and directory layouts that stay legible at ten thousand files and through a decade of future-you; pacing and budgets that turn acquisition from a burst into a sustainable season; metadata as the archive's true index — the record that makes a pile of tensors into a library; and the immutability discipline that separates archives from folders: never overwrite, never delete, revisions are new things.

   Lesson list (5)

   • 01
     Storage That Outlives Services~12 min · storage, nas, 3-2-1, failure-domains
   • 02
     Naming and Layout That Scale~11 min · naming, directory-structure, conventions, tooling
   • 03
     Budgets and Pacing~11 min · pacing, budget, planning, politeness
   • 04
     Metadata Is the Real Index~11 min · metadata, records, library-science, catalog
   • 05
     Never Overwrite, Never Delete~11 min · immutability, append-only, revisions, safety

   ✓Quiz · 5 questions→

6. 06⚙️The Woodpile App

   0/5 lessons

   The pipeline, running — decision before bytes, monitor without watching

   Every principle so far has a working implementation: the family's open-weight archive app, running in production. This final track walks its four surfaces as case studies of the quest's ideas under load. Composer is the thin intake where decisions are argued before any bytes move — a human gate at the head of a byte queue. Library is the maker-grouped catalog where the archive's argument becomes a browsable index. Monitor is the automatic transfer engine: paced, resumable, verified, requiring no watching. Settings is policy as configuration — roots, rates, and budgets as dials rather than code. And the decision record closes the loop: even refusals are preserved, because the shape of the pile is defined as much by what it declined as by what it holds.

   Lesson list (5)

   • 01
     The Queue Before the Bytes~12 min · composer, intake, decision-first, human-gate
   • 02
     The Library Is the Argument~11 min · library, catalog, maker-groups, provenance
   • 03
     Monitoring Without Watching~11 min · monitor, autonomy, pacing, reliability
   • 04
     Policy as Configuration~11 min · settings, policy, configuration, architecture
   • 05
     The Decision Record~11 min · decision-record, audit, refusals, closing

   ✓Quiz · 5 questions→