Kubernetes is often seen as just a container orchestration tool, but its true value lies in its role as a platform for declarative infrastructure. The author argues that Kubernetes should be understood as a runtime that manages infrastructure based on the desired state you define. This perspective shifts the focus from simply orchestrating containers to leveraging a type system that clearly defines resource kinds like Pods, Deployments, and Services. Each resource type comes with specific rules and behaviors, akin to types in a programming language. When you apply a manifest to a Kubernetes cluster, it doesn't execute a script but rather submits a declaration. This declaration becomes part of the cluster's persistent state. Kubernetes' controllers continuously monitor and reconcile the actual state with your desired state. If something drifts, Kubernetes works to correct it automatically. Manual interventions often fail because they conflict with the desired state you've set. The author emphasizes that understanding this runtime behavior can simplify troubleshooting by distinguishing between what you want (spec) and what the system observes (status). The concept of GitOps fits seamlessly into this framework. GitOps treats Git as the source of truth for your desired state, while Kubernetes operates as the runtime that enforces this state. A GitOps controller ensures that any changes in Git are reflected in the cluster. If you make an adjustment using kubectl that contradicts what's in Git, the GitOps controller will revert it. This dual reconciliation approach highlights the importance of using kubectl primarily for debugging rather than for making changes in a GitOps-managed environment. Understanding these principles can lead to more effective cluster management and clearer operational strategies.