Learning OpenShift and Kubernetes with Windsurf

This post is part of our Everyday AI series crafted by WWT AI experts to enhance awareness and comfort with Generative AI (GenAI). Our goal is to empower you to harness GenAI's diverse capabilities and benefits, both professionally and personally. 

How AI coding assistant Windsurf helped me learn Kubernetes & OpenShift

"Is it supposed to be this hard?"

That was one of the first thoughts I had when I began diving into Kubernetes and eventually Red Hat OpenShift. I've been comfortable with Docker for a long time, but Kubernetes seemed much more complicated.  Learning containers for rather simple and small use cases was one thing.  Learning how to build and operate multiple clusters at scale was very challenging at first.  And that's where Windsurf, an AI coding assistant, greatly enhanced my learning.

This post is about how it transformed the way I learn, build and work day to day with Kubernetes and OpenShift

AI doesn't replace fundamentals

This is incredibly important, and I try to remember it every time I talk about AI tools and use them:

Windsurf or any AI is extremely powerful, but if you don't know what kind of question to ask, why or when to ask it, and validate the accuracy of any response, you can get into trouble quickly.

AI accelerates learning, but it doesn't replace the responsibility to learn.

Understanding the basics of:

• Kubernetes and OpenShift Architecture
• Deployments, Daemon Sets & Services
• Container Storage and Networking
• Manifests and Helm Charts
• CI/CD Pipelines
• Security models
• Resource limits
• Troubleshooting

…makes AI dramatically more effective.

It's like giving a power tool to someone who understands the craft: you're still doing the work, but now you can do it faster, safer, and hopefully with fewer mistakes.

Getting started: From Docker to Kubernetes

Kubernetes documentation is extensive and, for a newcomer, a bit overwhelming. 

That documentation suddenly looks very complex

That's where Windsurf stepped in.  Instead of hours digging through specs, blogs, and Reddit threads, I could simply ask:

"Translate this Docker Compose file into a Deployment, Service, and Ingress Route in OpenShift."

"Why is my pod crashing? Here are the logs."

"What are some common causes of this error message with the top solution"

"Write a Deployment YAML for this new app A, base it off of what I already did for App B, keep the same structure and change these X number of things.

"Look at this deployment I am working on, it is working as expected, but are there things that could improve it's structure? Am I deviating from best practices, show me what is missing, and why it needs to change"

There is still plenty of time spent with traditional searching through Github repos, Helm Charts, Reddit posts, etc..   But while that was 100% the norm for me before Windsurf, I'd say it's about 90% in Windsurf and 10% reading through documentation now, with most of my time spent directly in Windsurf creating code for whatever application or use case I am working on at the time.

Windsurf works for me because it is very good at explaining things in a way that makes the concepts stick, not just fixing the problem.  You can just let it fix the problem and move on, which sometimes I do, but since I am trying to learn this, I always try to read through what it is recommending, and make sure it makes sense, before I go forward

The magic of autocomplete & predictive YAML

One feature I didn't expect to become addicted to was Windsurf's autocomplete.

It's not like traditional IDE autocomplete that pops in a few suggestions. Windsurf feels like it reads your mind. It knows:

• Where you are in a YAML file
• What fields usually go in that section
• What you've been trying to accomplish
• How OpenShift's syntax differs from vanilla Kubernetes

Before Windsurf autocomplete:

I'm Googling YAML schemas, making typos, forgetting indentation rules, and guessing at fields.

After Windsurf autocomplete:

It basically lays out the entire structure for me, correctly, following best practices—even when I forget what belongs there.

I can't emphasize enough how much time this saves. Instead of rewriting the same boilerplate for the 50th time, I just hit Tab, check for accuracy, and keep moving. It's the difference between typing every line manually versus having an intelligent assistant generate the majority of the manifest automatically.

YAML: From enemy to friend

Before Windsurf, YAML was very much like JSON to me, also something I overall understood, but the formatting and indentation intricacies always challenged me. One bad indent and your whole app is messed up.

Here's an example of the kind of mistake I could make:

Broken YAML (before Windsurf):

What's wrong here?

• Replicas indentation off
• Missing colon after ports
• Container port missing colon
• Missing selector section
• Template labels not aligned
• Several nested spacing errors

Corrected YAML (after Windsurf):

Windsurf not only fixed this—it explained why each detail mattered, turning each correction into a teachable moment.  Over time, this improved my intuition and confidence dramatically. I started recognizing patterns, best practices, and common gotchas without needing to look them up, fixing them myself.

Learning GitOps, ArgoCD and OpenShift

GitOps was another area where Windsurf made a huge difference. We use ArgoCD extensively, and understanding how it:

• Watches repositories
• Reconciles changes
• Overrides manual cluster changes (This was key for me)

…can be a lot for someone new to OpenShift.

ArgoCD is great, but with any tool, knowing its capabilities and how to most effectively work with them is crucial.  One of my biggest challenges was manually applying changes and having them overwritten by Argo and not always realising that was happening.   Depending on the type of change, I may have wanted to quickly test something, before I commit to Git.   If you aren't aware of what you can, and can't do, when Argo is in your environment, it can lead to a lot of tail chasing.  Questions like

"Why isn't my ArgoCD app syncing?"

"What does 'out of sync' mean in this context?"

"Why does ArgoCD keep reverting my manual changes?"

became easy to reason about with step-by-step guidance.

Over time, I was much more sure of myself and much better at making changes the right way, knowing how Argo worked in my environments.

Log file analysis

Logs in Kubernetes or any system, can be tedious to comb through.

I've pasted over 1,000 lines of logs into Windsurf while investigating issues. It skimmed, categorized, summarized, and surfaced the real issue in seconds. It pointed directly to the failing container and told me why it was possibly failing and where to look next until the issue was resolved.

That kind of speed changes everything. Instead of drowning in text reading line by line at human speed, you get to focus on solutions in seconds.

Running Docker-based applications in Kubernetes / OpenShift

A lot of applications have good Docker documentation—but that does not always translate to good Kubernetes documentation.  I think its mainly a product of how many applications are originally developed, on a developers laptop that isn't running Kubernetes, it's running Docker.  It's quick, uses less resources, and honestly not everyone designs applications with Kubernetes in mind.  

Windsurf fills that gap beautifully:

• It converts docker run commands into full Deployment + Service + Route bundles
• It reminds you of OpenShift-specific constraints
• It builds manifests that follow GitOps best practices
• It fixes missing fields or broken image references

This dramatically reduces the time between an app running great in Docker to having to figure out how to run it in OpenShift.

Memory: The feature I didn't know I needed

One of the most underrated aspects of using Windsurf is how well it remembers things.

It keeps track of:

• My repo layout and folder structure
• My environment's uniqueness
• My manifest format and naming structure, example 01-namespace.yaml, 02-pvc.yaml…
• Previous solutions to recurring or similar issues
• What tools I normally use
• My strengths and limitations

Unlike a typical stateless chat, Windsurf feels like working with a colleague who actually remembers past conversations and learns how I think.

This dramatically cuts down on repetitive questions and rebuilds context instantly.

Doing things I never thought I could do in Kubernetes

Before AI tools like Windsurf, some Kubernetes tasks felt completely out of reach.  Now, I'm doing things I wouldn't have attempted a year ago:

• Standing up new applications on OpenShift
• Debugging init container failures
• Creating custom health checks
• Managing complex GitOps directory structures
• Troubleshooting cluster networking and storage
• Recovering workloads
• Automating app deployments end to end

It's not because Kubernetes got easier overnight, it is still very complex.  It's because I now have a knowledgeable co-pilot who removes friction from the learning and troubleshooting process.

When an Outage Hit… and our Expert Wasn't Available

Recently, we had a data center-wide power outage in the ATC on a Friday afternoon, which took down everything: core network, DNS, storage, VMs and our multiple OpenShift Clusters.  Things that were supposed to survive multiple failures did not.  Our most experienced OpenShift architect—the person who built the majority of our OpenShift infrastructure was unavailable.

Our Team came together on a Teams call, and we started figuring out what was up, what was down, and, more importantly, how we should bring the various systems online and in what order.   Our first order of business was restoring core networking and storage.   Once those were stable, we turned our attention to OpenShift.   We have a variety of physical and virtual OpenShift Clusters, which were all impacted in various ways.

We knew enough to get started, what servers were for what cluster, what was down, etc.. We began by examining the current state and using Windsurf to review logs and provide suggestions based on what had happened.  

We fed it logs, ArgoCD errors, steps we had already taken, and whatever else we had. And it responded with:

• Realistic assessments
• Safe recovery steps
• Warnings about risky commands
• Explanations about why pods were getting stuck
• Guidance on how to restart or reconcile critical services

Piece by piece, Windsurf helped identify the issues and recover all major workloads in about 3 hours.

Without it, and the concepts I had already learned, that outage might have taken longer to recover.

It didn't replace our Teams expertise—it gave us enough clarity to act decisively when a key resource wasn't available.

AI didn't replace the learning process—it amplified it

Windsurf has become an essential part of my daily workflow. It changed how I troubleshoot, how I write YAML, how I approach GitOps, and how confident I feel operating in Kubernetes and OpenShift.

It helped me:

• Learn faster
• Avoid massive time sinks
• Reduce errors
• Write manifests more cleanly
• Understand fundamental concepts more deeply
• Automate repetitive tasks

Most importantly, it made Kubernetes feel approachable.

• What used to take hours now takes minutes.
• What felt overwhelming now feels doable.
• What would have previously blocked me now becomes a great learning opportunity.

It's not always 100% accurate; it can go down rabbit holes and loops if you let it, and as I mentioned at the beginning of this post, you absolutely have to know the fundamentals.  Overall, it has dramatically impacted me in a positive way and allowed me to become much more productive in a technology that, as recently as a couple of years ago, was something I never thought I would understand.