# Building kubectl Fluency: Why Twenty Small Reps Beat One Big Lecture

## What this module is, and why it looks different from the last one

ROOT 05's mental model module (m00) taught you the CONCEPT of desired state and gave you your
first `kubectl` commands. This module does something deliberately different: it's a breadth
drill across the everyday `kubectl` vocabulary you'll type dozens of times a day as a working
Kubernetes engineer — labels, JSONPath, dry-run manifests, patch, field selectors, sort-by,
diff, init containers, static Pods, and more.

There's no single narrative thread connecting these twenty tasks, and that's intentional. Real
`kubectl` fluency isn't one big insight — it's having enough of these small, specific commands
already in muscle memory that you're not stopping to look up syntax while you're mid-incident.
Each task below explains the specific concept it covers in its own description; your job is to
work through them, not to memorize a lecture first.

## How to approach this module

- **Don't try to do them in one sitting if you don't need to.** These are independent — skip
  around, come back to ones you found awkward, and don't feel obligated to treat this as one
  continuous session.
- **Read each task's own explanation before reaching for the hint.** Every one of these
  twenty tasks includes real context in its description — that context IS the teaching content
  for that specific command. The hint is there for when you're stuck, not as the first thing to
  read.
- **Notice which commands you reach for confidently versus which ones you have to think about.**
  That gap is exactly what the reflection at the end of this module asks you to name.
- **This breadth matters more than it looks like it does.** `kubectl explain`, `--dry-run`,
  JSONPath output, and `kubectl patch` in particular are commands experienced engineers use
  constantly and newer engineers often don't know exist at all — this module exists specifically
  to close that gap early.

## Instructor Notes

**Lesson goal:** Frame this module correctly before students hit it — it's a breadth-practice
bank, not a single-concept lesson, and the individual task descriptions carry the teaching
content. Without this framing, students sometimes expect a lecture and are confused when they
land directly on twenty short tasks.

**Approximate timing:** 5 minutes to introduce; the module itself runs long (20 tasks) and is
meant to be worked through at each student's own pace, live or between sessions.

**Facilitation for a live cohort:** Consider live-demoing 2-3 of the less obvious ones
(`kubectl explain`, JSONPath output, `kubectl patch`) rather than all twenty — the goal is to
unblock students on the commands they're least likely to have seen before, not to walk through
every task.

**Expected takeaway:** Kubernetes fluency is built from a large vocabulary of small, reliable
commands, not just conceptual understanding — this module is where that vocabulary gets built.