Vitthal Kaul

Student | Open Source Contributor @kubernetes | K8s Hindi Docs Reviewer | Learning and exploring the Cloud, Cloud Native and DevOps world

[Vitthal Kaul @Babapoool]

It is a dream come true for me after I started contributing with @kubernetesio SIG-Docs. I want to thank @reylejano and @JimmAngel for sponsoring membership. I hope to continue contributing much more in K8s and other OSS projects 🥳✌️

[Kubernetes @kubernetesio]

Thanks to everyone for a fantastic KubeCon India! 2026 still has even more to offer--we hope to see you soon at KubeCon Japan (July 28-30, Yokohama), KubeCon China (September 8-9, Shanghai), and KubeCon North America (November 9-12, Salt Lake City, US)!

[Suman Chakraborty @itsmesumanc]

Day 2 Kubecon kicks off 🚀
#cncf #kubecon

[CNCF @CloudNativeFdn]

Big update for your #CloudNative journey!

CNCF and @Linux_Education are partnering with @Udemy to bring you a unified training & certification path.
Now, you can buy high-quality training and your official CKA, CKAD, CKS, or CNPE exams together in one seamless, frictionless bundle directly on Udemy.

Fewer steps, faster upskilling, and industry-standard credentials!

Get started today! https://t.co/3cSKKxbdiL

[Saiyam Pathak @SaiyamPathak]

OMG - Fanboy moment ❤️ Linus Torvalds is in the house #ossindia

[kubesimplify @kubesimplify]

Linux Foundation Tokenomics Foundation 🧵
(One of the most under-covered cloud-native announcements of June 2026.)

[Arpit Bhayani @arpit_bhayani]

In my Applied AI Cohort, at the end, when we chit-chat, someone asked this question: Given that AI is generating most of the code, is it even useful to learn new languages deeply? Here is my take.

You should learn at least one programming language really well - like, really, really well - and know the specifics of others.

For example, if you are building something in Go for the first time, you can get far by prompting your way through it. You can ship working code without knowing the basics.

But yes, you can read the code, but can you truly understand it? Let me double down...

Go has goroutines and channels. Rust has ownership and lifetimes. These are not syntax details; they are mental models.

AI can generate code in a language you do not know, but it cannot generate intuition for a language you have never understood.

When a deadlock happens, memory usage balloons, or a race condition surfaces, you need that mental model to reason about it. AI cannot hand you that reasoning.

According to me, what AI changes is the ramp-up time - more specifically, syntax friction. That cost is now close to zero. The remaining work is the interesting part: building intuition for how the language thinks.

So, you do not need to memorize every standard library method in every language. But you do need to deeply understand at least one language and then pick up the specifics of others as needed.

That depth in one language gives you the mental model to reason about all the others.

As engineers, our job is to solve problems, not necessarily to write code.

Hope this helps.

[Saiyam Pathak @SaiyamPathak]

KubeCon India Coffee Chat: Giveaways, Stories & Survival Tips https://t.co/0OV7ea67pc

[Saiyam Pathak @SaiyamPathak]

The Mega KubeCon + CloudNativeCon India Livestream is happening tomorrow with amazing speakers and giveaways so do not miss this one.

[Vitthal Kaul @Babapoool]

@SaiyamPathak @thesaloninarang Great explanation 💯💯! Now I understand how our prompts return the answers under the hood. Thank you

[Saiyam Pathak @SaiyamPathak]

How LLM’s work from promt to response? I wrote it and its been the most read in my series, I highly recomment reading it.
The next one is on all the quantisation and what it means.

[Kubernetes @kubernetesio]

Kubernetes turns 12 today!💙

Today, we're celebrating Kubernetes and everyone who has been part of its journey over the years. Thank you for helping shape the past 12 years and for building what's next.

Happy Birthday, Kubernetes!🎉

#Kubernetes #CloudNative #OpenSource #CNCF

[Saiyam Pathak @SaiyamPathak]

Massive giveaway and massive livestream coming up!
You cannot miss this, mark your calendars for 8th June!

[Gergely Orosz @GergelyOrosz]

Podcast episode with a legend: Kelsey Hightower (out now)

Probably the best storyteller I’ve met - and what incredible stories he has!

[Saiyam Pathak @SaiyamPathak]

Jobs Kahan hai + Q/A https://t.co/khaauXMgfb

[CNCF @CloudNativeFdn]

Catching Kubernetes policy violations in CI/CD or at the admission controller works, but it forces builders to context-switch. Moving validation to review-time fixes this by putting policy feedback right inside the pull request.

Read the full post on layered governance: https://t.co/swbiJEWZn4

[Ivan Velichko @iximiuz]

A microVM is not a sandbox. It's an important integral part, but the isolation it provides is not sufficient. Agent confinement is a complex problem that requires a complex solution.

A quick example of how running an agent in a microVM doesn't prevent a breakout: https://t.co/gHPTBCNhP5

[The Linux Foundation @linuxfoundation]

🚨 A huge moment for the open source community in India.

For years, Linus Torvalds and Dirk Hohndel have taken the keynote stage together at Open Source Summits around the globe - and next month this must-see conversation is coming to Open Source Summit India!

You can’t miss this. Join us 16-17 June in Mumbai at the Jio World Convention Centre.

Register today! https://t.co/esOg8WNA98

#OSSummit

[Matt Pocock @mattpocockuk]

Tactical vs Strategic Programming, and why I'm nervous for juniors:

Good programming involves a mix of tactical and strategic decision-making:

- Tactical: on the ground, short-term. The soldier doing the fighting.
- Strategic: high-view, long-term. The general planning the war.

You need to be a tactician to write good code. To choose the right syntax. To figure out the file structure. To figure out how best to test your changes.

But you need to be a strategist to build code that lasts. To design the architecture. To automate away problems. To think beyond today.

Agents have eaten the tactical part of programming. When you can pay below minimum wage for code, there's no point going into the trenches yourself.

But AI cannot code strategically. Agents need someone at the top of the pyramid to tell them what to do. They need oversight.

So, a developer's day-to-day job has become 100% strategy. Long-term thinking, all the time. (maybe this is why I'm so tired all the time now)

If you identify as a tactical programmer - a code monkey - then you are out of luck. The job has changed.

Personally, I like it. I always preferred thinking strategically about code. If you asked me what my job was about, I'd say 'building apps', not 'writing code'.

But what makes me nervous is that we've pulled down the only bridge that brought juniors into the industry.

We used to train juniors like this:

1. Give them only tactical tasks
2. Let them build up their strategic experience slowly

Eventually, they are a good enough strategist that they are no longer a junior.

But what happens when all tactical code is written by AI? What is the point of a junior?

We obviously need juniors. We need new lifeblood coming into the industry. We need to leave paths open for extraordinary hires to enrich our companies.

But how do we train them? How do you train strategic thinking?

These are the questions I'm thinking about. I'd love to know your thoughts.

[Arpit Bhayani @arpit_bhayani]

How to design great systems? The answer is simple: design for failure. Great systems are not just built for happy paths, but they are designed to handle errors gracefully. I know this sounds like AI slop, but it is not ..., coming back...

Assume and acknowledge that every component, from hardware to software, has the potential to fail. So, proactively consider all possible failure points for every single component, and see how your system reacts.

In any case, the system should not simply collapse; instead, it should be designed to limit and contain the damage while maintaining core functionality, and ideally, recover quickly with minimal disruption.

This is the framework that I have been applying while designing any and every system across my career. For me, it is all about failures :) I seem a pessimist that way, but for me it is not pessimism, but realism.

Hope this helps.

[Ivan Velichko @iximiuz]

Kubernetes started as a scheduler layer on top of a set of single-host Docker daemons, which means that for a long time, Kubernetes pods were just "semi-fused" groups of Docker containers.

Eventually, a Container Runtime Interface (CRI) was introduced, enabling the swapping and tweaking of container runtimes. Most clusters moved from the bloated Docker to the more-focused containerd as the "higher-level" runtime, while the lower-level OCI runtime (runc) stayed unchanged.

However, the need for more isolated pods kept growing, and "alternative" (to Docker-style containers) implementations followed - most notably gVisor and Kata Containers.

gVisor runs containers atop a trimmed user-land kernel (written in Go), and Kata Containers wrap traditional Linux containers with microVMs for extra isolation.

Naturally, a need to specify a container runtime on the pod level emerged. And that's how the RuntimeClass resource was introduced.

With a RuntimeClass, you can tell Kubernetes which container runtimes cluster nodes support, enabling the cluster to run both traditional Linux container-based pods and more isolated gVisor or Kata Container pods.

```
kubectl apply -f - <<EOF
apiVersion: v1
kind: Pod
metadata:
name: nginx-kata-qemu
spec:
runtimeClassName: kata-qemu
containers:
- name: nginx
image: nginx:alpine EOF
```

Learn how to register new Runtime Classes and schedule pods with arbitrary runtime class names in this hands-on tutorial by Márk Sági-Kazár: https://t.co/U4pGKJGZxJ