The Dog Days Are Over

It’s been a while.

Not just since I’ve written something here. It feels like it’s been a while since I’ve had the particular kind of energy that usually makes me want to write something here.

Summer has a funny way of doing that.

The days get longer. Schedules get looser. The kids are home. Projects start piling up in various states of completion. Somewhere along the way, the things I was absolutely going to accomplish over the summer quietly became things I might get around to eventually.

I built things. I read things. I took some certification exams. I bought entirely too much LEGO.

But there was also a lot of waiting.

Waiting to figure out what came next professionally. Waiting through interview loops. Waiting for offers. Waiting for summer to end and whatever the next version of normal was going to look like to begin.

Now it has.

The dog days are over.

I started a new job at groundcover, which means my brain has once again been dropped into one of its favorite environments:

I don't know enough yet.

There’s a new product to understand. New architecture. New customers. New problems. New terminology. New people who know things I don't.

For some people, that probably sounds exhausting.

For me, it turns out to be fuel.

Knowing Isn't Doing

For the better part of the last year, I’ve been working my way through the Kubestronaut certifications.

Kubernetes. Prometheus. Argo. Backstage. Kyverno. Cilium. OpenTelemetry.

I've passed a bunch of them.

And then I ran into the practical exams.

Hard.

The frustrating part was that I was putting in the work.

I took the courses. I read the documentation. I did the labs. I understood the concepts. Ask me what a Deployment does or why you would use a NetworkPolicy and I could explain it.

Then put a clock in the corner of the screen and tell me to build it.

Suddenly everything changed.

I knew what I needed to do.

I just couldn't do it fast enough.

That bothered me.

My first instinct was the obvious one: learn more.

Another course. More documentation. More studying. Go back over the material I missed.

But eventually I started to realize that I wasn't failing because I didn't understand Kubernetes.

I was failing because understanding wasn't the skill being tested.

Execution was.

The Muscle

The theoretical certification exams had largely become an exercise in memorization.

Study the material. Learn the concepts. Recognize the patterns. Pass the exam.

I've gotten pretty good at that.

The practical exams didn't care nearly as much about what I could recall.

They wanted muscle.

kubectl needed to stop being something I knew how to use and become something my fingers knew how to use.

I shouldn't have been thinking about how to generate a YAML skeleton, where a particular field belonged or which command would get me the information I needed.

Thinking takes time.

And time was exactly what I didn't have.

That exposed an uncomfortable gap in the way I'd been learning.

I had accumulated knowledge without accumulating enough repetitions.

It's the difference between knowing how a guitar chord is formed and being able to change to it in the middle of a song.

You don't fix the second problem by reading another book about guitar chords.

You pick up the guitar.

Again.

And again.

And again.

So I Needed Reps

Once I understood the problem that way, the answer seemed obvious.

I needed more hands-on time.

Not another twelve-hour video course.

Not another hundred-question practice test.

I needed someone to hand me a broken cluster and tell me to fix it.

Then another.

Then another.

I needed to create the same resources enough times that the boring parts became automatic.

I needed to make mistakes somewhere that mistakes were cheap.

And I needed feedback.

That last part turned out to be important.

Because practicing something incorrectly fifty times is still fifty repetitions.

What I wanted was something closer to a gym than a classroom.

Here's the environment.

Here's the objective.

Go.

When you're finished, something should be able to look at what you built and tell you whether you actually accomplished it.

Then tear the whole thing down and do another one.

Which raised an interesting question.

Why wasn't I building that?

Of Course I Built Something

The original idea was relatively simple: build myself better Kubernetes labs.

That lasted approximately five minutes.

Because once you start thinking about what a good lab actually requires, the problem gets more interesting.

What if the environment could create a real cluster for you?

What if a lesson wasn't just a page of instructions followed by a terminal somewhere else?

What if the lesson knew what you were supposed to build?

What if it could inspect the environment afterward?

What if it could tell the difference between something that technically works and something that was actually built correctly?

What if the environment disappeared when you were done?

What if the system tracked where you were slow?

What if it noticed that you could create a Deployment without thinking but consistently lost four minutes troubleshooting an Ingress?

What if the next exercise took that into account?

At some point, I stopped thinking about the thing I was building as a collection of Kubernetes labs.

It started looking like a learning system.

And there it was.

The thing that always gets me.

A system.

Suddenly I wasn't trying to convince myself to study harder.

I was thinking about ephemeral infrastructure. Cluster provisioning. Validation engines. Learning paths. Sandboxed environments. Authentication. Observability. Progress tracking.

I was learning again.

I just wasn't studying.

New Inputs

Starting at groundcover has only accelerated that feeling.

Observability isn't new to me. I've spent years around it.

But a new platform gives you a different lens through which to look at familiar problems.

And new lenses create new questions.

Questions are dangerous.

Questions become terminal windows.

Terminal windows become repositories.

Repositories become architecture diagrams.

Architecture diagrams become me explaining to my wife why the thing running in the basement is absolutely necessary.

This is more or less how every project I've ever cared about has started.

The garage wasn't really about the garage.

Alpha-5 wasn't really about running a local LLM.

And this isn't really about becoming a Kubestronaut.

They're excuses to pull on a thread.

The interesting part is finding out what's attached to the other end.

Knowing Isn't Doing

There's probably a broader lesson buried in all of this.

I've spent a lot of my career learning things.

I've taken courses. Read books. Earned certifications. Built labs. Watched conference talks. Read documentation until the tabs across the top of Chrome became too small to identify.

All of those things have value.

But knowledge has a strange way of making you feel more capable than you actually are.

You can understand something deeply and still be terrible at doing it.

The only thing that seems to close that gap is repetition.

Not mindless repetition.

Deliberate repetition.

Do the thing.

See where you struggled.

Understand why.

Do it again.

Make the feedback loop shorter.

Then repeat it until the thing that once consumed all of your attention becomes boring.

Because boring is interesting.

Boring means the mechanics have disappeared.

And once the mechanics disappear, you have room to think about the system again.

Maybe I still become a Kubestronaut.

I'd like to.

But getting there apparently requires something different than what got me this far.

So I'm building it.

Summer is ending.

There's a new job. New technology. New people to learn from. New systems to understand.

There's a little more energy than there was a few months ago.

And, because I am apparently incapable of encountering a personal problem without eventually trying to turn it into infrastructure, there's a new system taking shape in the background.

The dog days are over.

Time to get some reps.