Glossary

Canonical definitions of /root terminology — Workload CRD, basecamp tiers, STUB/OUTLINE/DEEP, run-pray-build, the K8s-native ecosystem, and the other terms that recur across the 207 files. Sorted by category.

The /root curriculum is dense with terminology — much of it specific to the program, some borrowed from the K8s + ML ecosystems. This page is the decoder. Read top-down once; refer back whenever a phase doc uses a term you can’t place.

Program structure

/root — The 5-year self-authored curriculum from Software Engineering Foundations to ML Platform / AI Infrastructure. Pattern-first, platform-driven, resource-neutral. Path-styled to evoke the “root principle” metaphor — every phase asks you to find the root of the problem before the tool. See Master Plan.

Abukix — The brand the curriculum produces. Named after the author’s surname. Single-namespace identity: abukix.dev (domain), abukix-root/ (workspace), Abukix Studio (the Year 5 product surface). See brand/identity.

basecamp — The K8s-native platform /root builds across Y3-Y5. Nine tiers: Foundation / Reliability / IaC + Cloud / Platform Control / Data / ML Infra / LLM-Agent / AIOps / Studio MVP. Also the name of the GitOps repo that declares the platform. See basecamp plan.

Phase — The unit of /root. ~50 phases total across 5 years. Each phase is 5-10 weeks at 12 hrs/wk and follows the 8-step scaffold (PROBLEM → PRINCIPLES → TRADE-OFFS → TOOLS → MASTERY → COMPARE → OPERATE → CONTRIBUTE). See any phase doc, e.g., Y3 Phase 20.

Year — Thematic grouping of phases. Each year ends at a credible role exit ramp (Y1 → Junior SWE; Y2 → Mid-Backend; Y3 → Senior DevOps/SRE/Platform; Y4 → Senior Data/ML; Y5 → ML Platform / AI Infrastructure). Year boundaries are pace-flexible; the program is the 50 phases, the years are the theme.

Senior IC — Senior Individual Contributor. The /root program’s exit-ramp target role (ML Platform / AI Infrastructure at a frontier lab). Distinct from a management track. See overview.

Final Exam — Each year ends with a 6-hour scenario-based exam covering its phases. Year 5’s exam is paired with the Capstone: Abukix Studio MVP + the Pattern Paper.

Capstone — The Year 5 deliverables: Abukix Studio MVP launched publicly + the Pattern Paper (3,500-5,000 word synthesis essay). The artifacts that close the program. See The Capstone.

Pattern Paper — The Y5 Capstone synthesis essay. The single highest-stakes doc the program produces. Audience: Staff/Principal-level hiring managers. Reviewed by 2+ external readers before publishing. See pattern-paper outline.

Pattern library mechanics

Pattern — The durable knowledge artifact /root produces. The timeless shape of a problem and the principled trade-offs any solution must make. Tools change; patterns don’t. The library is what survives the 5 years and outlives the specific tools you’ll have learned.

Pattern Library — The full corpus of pattern entries at /patterns/. ~75 entries across 10 categories at graduation. See Pattern Library.

STUB / OUTLINE / DEEP — The pattern depth ladder.

  • STUB — frontmatter + 1-paragraph summary. Default state. Created when first referenced.
  • OUTLINE — promoted when a phase first touches the pattern. Adds Problem · Principles · Trade-offs · Tools sections.
  • DEEP — promoted after 3+ months of operating something that depends on the pattern. Adds Mastery · Compare · Operate · Contribute sections.

The depth is a property of operating evidence, not a label on the entry. A DEEP claim without operating evidence is a lie to yourself. See pattern template.

8-step pattern-first scaffold — The structure every phase doc follows: PROBLEM → PRINCIPLES → TRADE-OFFS → TOOLS → MASTERY → COMPARE → OPERATE → CONTRIBUTE. The COMPARE step (re-implement the same problem in a second tool) is the non-negotiable proof of pattern fluency. See overview.

Pattern-first — The framing rule. Every concrete tool sits inside a named pattern; name the pattern before naming the tool. The opposite is tool-first, where engineers identify by their tools and re-learn their identity every 5 years.

Investigation prompts — Phase docs guide; they don’t supply answers. An investigation prompt is a question the phase asks you to investigate yourself (“Walk a Crossplane-driven platform: XRDs reconciled by Compositions”). Claude (and the root-tutor skill) refuses to answer these — guide, not spoon-feed.

Artifacts you produce

Weekly log — Sunday entry. ~1-2 hours. Five sections (what I did / what I learned / what surprised / what’s stuck / next week). The single most-load-bearing habit of /root. ~250 entries by graduation. See weekly-log template.

Runbook — Recipe for a single operational task. Trigger → pre-reqs → numbered steps with expected outcomes → verification → rollback. ~140 runbooks by graduation. See runbook template.

Postmortem — Blameless analysis after every real incident. Summary / impact / timeline / root cause / what went well / poorly / action items with owners + dates. ~25 by graduation. See postmortem template.

ADR (Architecture Decision Record) — One-page artifact recording a single architecturally-consequential decision. Context / decision / consequences (positive, negative, neutral) / alternatives considered with why-rejected. ~15 by graduation (basecamp + ops-handbook combined). See adr template.

Blog post — Monthly Y3+. ~800-2,000 words. Tied to a specific moment (incident, ship, pattern promotion). Pattern-first. Carries receipts (commits, runbooks, dashboards). ~36 by graduation. See blog-post template.

ops-handbook — The private longitudinal corpus where weekly logs, runbooks, postmortems, and ADRs accumulate. Started Y1 Phase 1; runs through graduation. Indexed by Y5 AIOps as the RAG corpus. Always private. See ops-handbook plan.

Pattern Library entry — See Pattern above. Note the entry’s depth (STUB/OUTLINE/DEEP) is the public claim about how much operating evidence backs it.

Project README — Each OSS project’s front door. ~10 across the program. Standardized via the project-readme template.

Operational discipline

AI Learning Protocol — The 7 rules that govern how the operator uses AI in /root. Most load-bearing: guide-not-spoon-feed, patterns-before-tools, validate-then-write, push-back-on-shallow, never-write-the-exercise. See program/ai-learning-protocol.

Validate-then-write — Rule #3 of the AI Learning Protocol. Claude iterates the operator’s draft. Claude does NOT write the operator’s first draft — especially for weekly logs, pattern entries, postmortems, the Pattern Paper. The template is the contract; AI fills inside sections the operator has drafted.

Run-pray-build — The daily-rhythm triad. Run for the body. Pray for the spirit. Build for the craft. None alone is sustainable over 5 years; all three together is the only stable configuration. See story.md — the rhythm.

Public-safety audit — The 2026-06-29 sweep that removed Apple-internal product names from all src/content/docs/ content. The audit guarantees the public-intended docs leak no internal terms. The forbidden-terms list lives at ~/abukix-root/INTERNAL-PARALLELS.md (PRIVATE, never publish). Re-verified by the /pre-publish-check skill before any public flip.

Public-safety check — Operational version of the audit. Invoked via the /pre-publish-check skill before any publishing moment (basecamp goes public, blog post publishes, Studio launches).

OSS-over-enterprise preference — Default to OSS / community editions even when free enterprise tiers exist. Specific traps to flag: Proxmox subscription, Vault Enterprise, Grafana Cloud, Docker Desktop license, Terraform vs OpenTofu. See homelab/index — Why OSS-only.

Solo operator with disciplined review — The PR workflow encoded in ADR-0001 (lives at the repo root’s adrs/0001-solo-operator-with-disciplined-review.md): branch → PR → CI → overnight wait → merge. No fake-team multi-account simulation. AI as sanity check + external review at consequential moments.

Technology — K8s + cloud + ML

CRD (Custom Resource Definition) — Kubernetes API extension that defines a new resource type. The K8s-native way to declare domain-specific abstractions.

Operator — Custom CRD + custom controller that watches CRD instances and reconciles them into underlying state. /root builds two custom operators: platform-ctl at Y3 Phase 26, aiops at Y5 Phase 50. See operator-pattern.

Control-loop — The reconciliation pattern. Declared state → controller continuously drives actual state toward declared. The pattern under Kubernetes, GitOps, every K8s operator, thermostats, PID controllers. See foundations/control-loops.

GitOps — Git as the source of truth for desired state; a reconciler (Flux for basecamp) converges actual state to declared continuously. The control-loop pattern lifted up one layer to platform declaration. See gitops.

Flux — The K8s-native GitOps reconciler /root uses (versus ArgoCD). Composes naturally with Crossplane + Cilium + Strimzi + KubeRay + KServe in the K8s-native ecosystem. Bootstrapped at Y3 Phase 20.

Kustomize — K8s YAML overlay system. Per-cluster customization of a shared base. /root uses base/ + overlays/{k3s,eks,gke}/ shape. See k8s-templates/kustomize-overlay-pair.

Helm — K8s package manager. /root uses Helm via Flux HelmRelease CRDs; per-service Helm chart skeleton at k8s-templates/helm-chart-skeleton.

Workload CRD — platform.basecamp.io/v1alpha1 Kind. /root’s platform-contract API. Declares a service’s language, owner, SLO, targets, dependencies. The platform-ctl custom operator (Y3 Phase 26) reconciles it into the underlying state (Helm chart + Kustomize overlays + Flux HelmRelease + NetworkPolicy + SLO definition + runbook stub). See workload-cr-instance.yaml.

K8s-native ecosystem — The meta-pattern: every component is a CRD-driven controller composing through the K8s API. State in CRDs (not config files). Behavior in controllers. Composition through the K8s API. Uniform operational interface across every layer. See platform-patterns/#the-k8s-native-ecosystem-as-a-meta-pattern.

SLO / SLI / Error Budget — The SRE-book contract trio. SLI measures reality (e.g., success rate, p95 latency). SLO is the target (e.g., 99.5% success / 30 days). Error budget is what’s left to spend on planned risk. See sli-slo-error-budget.

Tier (basecamp 1-9) — basecamp’s nine vertical layers, named in order: Foundation / Reliability / IaC + Cloud / Platform Control / Data / ML Infra / LLM-Agent / AIOps / Studio MVP. Each tier depends only on the tiers below it. See capstone.

Industry framing

Frontier-lab — The generic framing for industry parallels (Anthropic, OpenAI, and the other organizations building frontier AI platforms). Substitutes for any specific company name when describing patterns. The 2026-06-29 audit replaced specific internal product names with “frontier-lab platforms” framing wherever industry parallel was needed.

Platform-as-product — The discipline that treats the internal platform as a product, developers as customers, developer experience as the unit of work. /root’s platform-ctl instantiates this. See pattern.

Building an AI Platform in Public — The /root brand pillar. The one sentence that gates every Abukix artifact: if it doesn’t visibly contribute to building, an AI platform, or in public, it doesn’t belong under the brand. See brand/identity.

Cross-references