The Terminal Was the Gym All Along

A few days ago, this didn’t exist.

I was thinking my training needed my own form of an LMS.

That made sense at the time.

I had drills. I had training material. I had this idea that Kubernetes certification prep shouldn’t just be another collection of videos, documentation, and practice questions. I wanted something built around actually doing the work.

So naturally, I started building a place to learn.

Then I realized I was building the wrong place.

This has become a recurring theme in the things I build. I start with a problem, build a system around it, and somewhere along the way, the system teaches me what the problem actually was.

KubeFit did exactly that.

I didn’t need another classroom

The idea for KubeFit came out of my latest attempt at continuing down the Kubestronaut path.

I’ve passed plenty of certification exams.

The theoretical ones have generally followed the same pattern: learn the material, understand the concepts, memorize enough of the details, take the test.

The practical exams exposed something different.

I knew Kubernetes.

That wasn’t the problem.

Put a broken Service in front of me and give me enough time, and I could probably tell you what was wrong with it.

But “probably” and “enough time” are doing a lot of work in that sentence.

The exam doesn’t care that I understand Services.

It gives me a terminal and a clock.

That distinction became the entire idea behind KubeFit.

I wasn’t missing knowledge.

I was missing muscle.

And you don’t build muscle by watching someone lift.

So I built a gym

Originally, I took the metaphor pretty literally.

KubeFit.

Training tracks.

Exercises.

Reps.

“Do you even kubectl apply?”

And, eventually:

Never skip lab day.

Corny?

Absolutely.

But underneath the joke was something I kept coming back to: if this is supposed to be training, it should actually feel like training.

Reading about a Deployment is useful.

Watching someone troubleshoot a Deployment is useful.

Even following along with a lab is useful.

But none of those are the same as opening a terminal, seeing a problem you’ve never seen before, and having to figure it out while the clock is running.

That’s the rep.

So KubeFit stopped trying to bring the terminal into the learning platform.

Instead, I moved the learning platform out of the terminal’s way.

And every good gym needs a mascot.

Meet Caz.

Caz is a penguin, and his name is a play on Tux, the Linux penguin. “Caz” is short for “Casual,” which is a fairly accurate description of his attitude.

He has somehow become the unofficial embodiment of the whole project.

Why a penguin?

Because Linux already gave us a great one.

Why does every side project eventually acquire a mascot, a terrible slogan, or both?

Also no idea.

But Caz fits.

He’s there to remind you that this is supposed to be fun, even when you’ve spent twelve minutes wondering why your Pods are perfectly healthy and your Service still has no endpoints.

Caz does not care about your excuses.

Caz wants reps.

kubefit drill cka

The new version of KubeFit is a CLI.

Run:

kubefit drill cka

and KubeFit creates the environment, seeds a scenario, gives you the task, and starts the clock.

Then it gets out of the way.

You’re back where you should be:

in your shell.

Using kubectl.

Reading the docs.

Breaking things.

Fixing things.

Questioning why the selector you have stared at for three straight minutes still isn’t selecting anything.

When you think you’re done:

kubefit grade

KubeFit doesn’t inspect the YAML file you wrote and decide whether it looks right.

It checks the actual system.

Does the Service have endpoints?

Does the workload respond?

Does the resource exist in the correct namespace?

Is the thing actually working?

That distinction matters.

Because the exam doesn’t care how elegant the command was.

The cluster either works or it doesn’t.

Then something clicked

Once the drills moved into the CLI, the website finally made sense too.

It wasn’t the gym.

It was the training log.

Every attempt becomes a rep.

KubeFit records whether you passed, how long it took, how many times you graded your work, whether you needed a hint, and whether you eventually had to look at the solution.

Passing isn’t even the entire goal.

I’m particularly interested in what I’ve started calling a cold pass.

First grade.

No hints.

No solution.

Under pressure, you knew what to do and did it.

That’s a very different signal from:

“I eventually figured it out.”

Both matter.

Only one tells me I’m ready to see that problem on an exam.

And once I had reps, I had data.

Once I had data, well…

Of course I built a system around it.

The system watches the weak spots

This might be the most me part of KubeFit.

I don’t want a dashboard that tells me I’ve completed 73% of a course.

I want the system to tell me what I should do next.

So KubeFit looks at the reps.

What haven’t I touched?

What did I fail?

Where am I passing but still too slow?

Where did I need hints?

Which domains carry more weight on the actual exam?

Then:

kubefit next

Go do this one.

Not because it’s next in Chapter 7.

Because that’s where the weakness is.

That’s the difference between a curriculum and training.

A curriculum tells everyone what comes next.

Training pays attention to the person doing it.

If I’m terrible at Services but somehow keep getting assigned another Deployment exercise because that’s what comes next in the book, I’m not training intelligently.

I’m just turning pages.

Caz would be disappointed.

Local was the missing piece

There was another realization hiding in all of this.

I kept thinking about how to build browser-based Kubernetes labs.

How do I provision clusters?

How do I isolate users?

How long do environments live?

How much infrastructure does that require?

How much does each lab session cost?

Those are interesting infrastructure problems.

They are also problems I didn’t actually need to solve.

KubeFit runs the drills on your machine.

For Kubernetes tracks, it can build the cluster locally, seed the failure state, grade it, tear it down, and build another one.

For Linux, it can give you a disposable VM.

The website doesn’t need to pretend to be your terminal.

You already have one.

That feels obvious now.

It wasn’t obvious when I started.

And I think that’s one of the more useful lessons from this whole thing: sometimes the best architecture is the one where you stop building the thing you thought you needed.

I could spend months building a very impressive remote lab platform.

Or I could let Kubernetes run where Kubernetes already runs.

The second option is considerably less exciting to explain in an architecture diagram.

It is considerably more useful to the person trying to pass the exam.

The loop got smaller

KubeFit has changed shape several times in a very short period.

Oddly, every time I’ve removed something, the idea has gotten clearer.

It has basically collapsed into three steps:

Read. Drill. Review.

Learn enough to understand the problem.

Do the work without someone holding your hand.

Look at what happened and decide what needs another rep.

Then repeat.

The site holds the concepts, playbooks, reports, and notebooks.

The CLI handles the work.

The cluster provides the truth.

No XP.

No progress bar pretending that reading another page made me better at Kubernetes.

No elaborate gamification layer trying to convince me that I’m having fun.

Just reps.

And maybe a penguin.

I think that’s what I was trying to build all along

A week ago, I thought I was building a Kubernetes learning platform.

I’m not sure that’s how I would describe it anymore.

I’m building the thing I wish I had when I realized knowing Kubernetes and being able to perform Kubernetes quickly were two different skills.

Maybe KubeFit helps me finally finish the Kubestronaut path.

Maybe other people eventually use it for theirs.

Maybe Caz becomes inexplicably popular and I end up putting him on stickers.

Right now, I’m mostly enjoying what happens when an idea stops fighting its own architecture.

The LMS wanted me to recreate the environment where the work happens.

The CLI just goes there.

And somehow the dumb gym metaphor I started with became more accurate than I intended.

You can read about Kubernetes all day.

You can watch someone else troubleshoot it.

You can memorize every flag in kubectl.

Eventually, though, you have to pick up the weight.

kubefit drill cka

Caz is waiting.

Never skip lab day.