<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Harsh Kumar on Medium]]></title>
        <description><![CDATA[Stories by Harsh Kumar on Medium]]></description>
        <link>https://medium.com/@hrk84ya?source=rss-31fb8ca6c045------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*jdBEIVWQ-m0_gZzL7ka96w.jpeg</url>
            <title>Stories by Harsh Kumar on Medium</title>
            <link>https://medium.com/@hrk84ya?source=rss-31fb8ca6c045------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 16:43:40 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@hrk84ya/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[The Difference Between Following a Tutorial and Actually Understanding Gradient Descent]]></title>
            <link>https://medium.com/@hrk84ya/the-difference-between-following-a-tutorial-and-actually-understanding-gradient-descent-bdec8fd38bf2?source=rss-31fb8ca6c045------2</link>
            <guid isPermaLink="false">https://medium.com/p/bdec8fd38bf2</guid>
            <category><![CDATA[fundamentals]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[gradient-descent]]></category>
            <category><![CDATA[deep-learning]]></category>
            <dc:creator><![CDATA[Harsh Kumar]]></dc:creator>
            <pubDate>Tue, 11 Aug 2026 01:31:01 GMT</pubDate>
            <atom:updated>2026-08-11T01:31:01.335Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Lecf02DMNa8Vx3Q9YElIeg.png" /><figcaption>Image generated with AI</figcaption></figure><h4>I could implement it from memory. I couldn’t have told you why it worked. Those turned out to be very different skills.</h4><p>I watched the same gradient descent explainer video that most people learning ML have probably watched — the one with the 3D bowl-shaped loss surface and a ball rolling down toward the minimum. I understood it immediately, in the sense that I could explain it to someone else. Loss function, gradient, learning rate, step downhill, repeat until convergence. I coded it from scratch on a simple linear regression problem the same afternoon, and it worked. I felt like I’d learned it.</p><p>Then I hit a problem where it didn’t work, and I realised how thin my understanding actually was.</p><h3>The moment the ball stopped rolling nicely</h3><p>I was training a small neural network on a slightly more complex dataset. The loss was doing something the bowl analogy hadn’t prepared me for: it would decrease for a while, then suddenly spike upward, then decrease again, in a pattern that looked less like a ball rolling downhill and more like a ball being flung around a room. I had no framework for diagnosing this. My mental model was “<em>gradient descent finds the minimum.</em>” It didn’t include a category for “gradient descent actively making things worse,” so I had nowhere to start.</p><p>I lowered the learning rate on a hunch, mostly because I vaguely remembered that being a knob people mentioned. It fixed the problem. I didn’t actually understand why until I went back and worked through the math I’d skipped past in the tutorial.</p><blockquote>My mental model was ‘gradient descent finds the minimum.’ It didn’t include a category for ‘gradient descent making things worse’ — so I had nowhere to start.</blockquote><h3>What I’d actually skipped</h3><p>The gradient tells you the direction of steepest increase in the loss, and you step in the opposite direction — that part I had down. What I hadn’t internalised was that the gradient only tells you the right direction locally, at the exact point you’re standing. It says nothing about how far that direction remains accurate as you move. If your step size — the learning rate — is too large relative to how quickly the slope changes, you don’t smoothly descend. You overshoot the minimum, land somewhere with an even steeper slope pointing back the way you came, overshoot again in the opposite direction, and the whole process can diverge instead of converge.</p><p>This is obvious once you’ve actually worked through what a derivative means as a local approximation, and how a fixed step size interacts with a loss surface that isn’t uniformly curved. It was not obvious to me from watching a ball roll down a smooth, conveniently-shaped bowl, because that visual specifically avoids showing you what happens when the surface isn’t smooth or when your steps are too big for the terrain.</p><h3>The second gap: what “convergence” actually means</h3><p>I’d also been treating convergence as a single, simple event — the loss goes down, flattens out, you’re done. Working through a case where my loss plateaued at a clearly bad value taught me the more useful version: gradient descent finds a local minimum, or a saddle point, or just a very flat region where the gradient is small enough that progress becomes glacially slow, and none of these is the same as “found the best possible solution.” Whether you’ve landed somewhere good depends on the shape of the loss surface, which depends on your model architecture and your data, in ways that no single explainer video can cover because it depends on your specific problem.</p><h3>What actually built real understanding</h3><p>Implementing it from scratch helped, but not as much as deliberately breaking it did. I started running the same simple regression problem with learning rates spanning several orders of magnitude and watching what happened to the loss curve at each one — too small, and it crawled; reasonable and it converged smoothly; too large and it diverged exactly the way my earlier network had. Seeing the failure modes on a problem simple enough to fully visualise made the abstract math concrete in a way that the working tutorial example never could, because the tutorial example was specifically chosen not to fail.</p><p>I also started reading the loss curve itself as diagnostic information rather than a pass/fail signal. A curve that’s smoothly decreasing tells you something different from one that’s oscillating, which tells you something different from one that’s flat from the start. Learning to read what the shape of the curve is actually saying about the optimisation process was the thing that moved me from “I ran gradient descent” to something closer to actually understanding it.</p><p>The tutorial taught me to make the ball roll. Breaking it on purpose taught me why it sometimes doesn’t.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bdec8fd38bf2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Trained My First Model and Got 99% Accuracy. Then I Found Out Why That Was a Problem.]]></title>
            <link>https://medium.com/@hrk84ya/i-trained-my-first-model-and-got-99-accuracy-then-i-found-out-why-that-was-a-problem-00dc9964d088?source=rss-31fb8ca6c045------2</link>
            <guid isPermaLink="false">https://medium.com/p/00dc9964d088</guid>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Harsh Kumar]]></dc:creator>
            <pubDate>Fri, 07 Aug 2026 01:31:01 GMT</pubDate>
            <atom:updated>2026-08-07T01:31:01.441Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7HEX7CptnUXUQfCOy-flXw.png" /><figcaption>Image generated with AI</figcaption></figure><h4>I was so proud of that number. It took a Reddit comment to ruin my week and teach me something real.</h4><p>The project was a customer churn predictor, built off a dataset I’d downloaded for practice — the kind of tabular data with customer signup dates, usage patterns, subscription tiers, and a churned/not-churned label. I followed a fairly standard pipeline: cleaned the data, engineered a few features, trained a random forest, and ran it against a held-out test set.</p><p>99.6% accuracy. I remember genuinely staring at the number for a while, half convinced I’d made an error, half already composing the LinkedIn post about it in my head. Neither instinct was entirely wrong. I had made an error. I just hadn’t found it yet.</p><h3>The comment that ruined my confidence, correctly</h3><p>I posted my notebook in a machine learning subreddit, mostly looking for feedback on my feature engineering. The top comment didn’t touch the features at all. It asked a single question: “What’s in your feature set — do you have anything that’s basically derived from the label?”</p><p>I went back through my columns. Buried among the usage features was one called days_since_last_login. It seemed innocent enough when I&#39;d added it — recency of activity felt like an obviously relevant signal for churn. What I hadn&#39;t thought through was how the dataset had been constructed: for customers who had already churned, this value was frozen at whatever it was on their last day, which meant unusually high values were almost perfectly correlated with the churned label, not because the model had learned something meaningful about behavior, but because the feature was leaking information about the outcome it was supposed to predict.</p><blockquote>The model wasn’t predicting churn. It was detecting that a value had stopped updating — which only happens after someone’s already gone.</blockquote><h3>What data leakage actually is, once you’ve seen it</h3><p>Every explanation of data leakage I’d read before this described it correctly but abstractly: information from outside the training data, or information that wouldn’t be available at prediction time, sneaking into your features and making your model look better than it actually is. I’d nodded along. I hadn’t understood it, because I hadn’t yet seen how easily it hides inside a feature that sounds completely reasonable.</p><p>The insidious part is that leakage doesn’t look like a bug. It doesn’t throw an error. It doesn’t produce a warning. It produces exactly the output you were hoping for — a great accuracy score — which means the only way you find it is by being suspicious of results that seem too good, and then actually going looking for the reason, rather than accepting the number and moving on.</p><h3>Where else it was hiding that I hadn’t noticed</h3><p>Once I knew what to look for, I found a second, quieter version of the same problem. I’d done my train-test split after computing a feature that aggregated usage statistics across the full dataset — average session length per customer segment, computed before the split. That meant information from the test set had leaked into a feature used to train on the training set, through the shared aggregation. Small leak, much smaller effect than the first one, but the same category of mistake: using information from the future, or from data that shouldn’t have been visible yet, to make the present look more predictable than it actually is.</p><h3>What actually fixed it</h3><p>I removed the frozen recency feature entirely and rebuilt any aggregated features so they were computed strictly within the training fold, never touching test data before the split. The honest accuracy, once both issues were fixed, dropped to somewhere in the mid-80s. That number stung a little after seeing 99.6%, but it was the first number in the whole project I actually trusted.</p><p>The bigger shift was in how I approached every project after that. Any time a result feels surprisingly good, my first move now is suspicion, not celebration — checking the feature list for anything that might be derived from or correlated with the label in a way that wouldn’t hold up at actual prediction time, checking that the split happened before any data-dependent computation, checking whether the “great” result would still make sense if I imagined explaining exactly how each feature was built to someone skeptical.</p><h3>Why this mistake is so common for beginners specifically</h3><p>Tutorials mostly use clean, pre-split, well-behaved datasets specifically so the modelling concepts can be taught without this kind of noise. That’s reasonable for teaching gradient boosting or hyperparameter tuning. It also means a lot of beginners — myself very much included — get to their first real, messy dataset having never had to think about where features actually come from and when they’d realistically be available. Leakage isn’t a modelling mistake. It’s a data hygiene mistake, and nothing about learning the models themselves teaches you to catch it.</p><p>85% that I trust taught me more than 99% that I didn’t understand. I’d take that trade every time now.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=00dc9964d088" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Kubernetes Resource Limits Quietly Break Your Application]]></title>
            <link>https://medium.com/@hrk84ya/how-kubernetes-resource-limits-quietly-break-your-application-cd823c584002?source=rss-31fb8ca6c045------2</link>
            <guid isPermaLink="false">https://medium.com/p/cd823c584002</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[production]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Harsh Kumar]]></dc:creator>
            <pubDate>Tue, 04 Aug 2026 01:31:01 GMT</pubDate>
            <atom:updated>2026-08-04T01:31:01.707Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OeCb0KE13QEr1xYD2YQChw.png" /><figcaption>Image generated with AI</figcaption></figure><h4>We set limits because a tutorial told us to. Six months later, they were the reason our app kept mysteriously restarting under load.</h4><p>Resource requests and limits were one of the first things I learned to add to a Deployment manifest, and one of the last things I actually understood. Early on, I treated them the way I treated a lot of Kubernetes boilerplate: copy roughly reasonable-looking numbers from a tutorial or a teammate’s existing service, apply them, move on. It took a production incident to make me actually learn what those numbers were doing.</p><h3>What requests and limits actually mean</h3><p>A resource request is what the scheduler uses to decide which node can fit your pod — it’s a reservation, a promise that this much CPU and memory will be available. A limit is a hard ceiling: if your pod tries to use more memory than its limit, Kubernetes kills the process immediately, with an OOMKilled status. CPU limits work differently — a container that exceeds its CPU limit doesn’t get killed; it gets throttled, meaning its execution is artificially slowed down.</p><p>This asymmetry between how memory limits and CPU limits are enforced is the detail that caused our specific incident, and I don’t think it’s explained clearly enough in most introductory material.</p><blockquote>“Exceed your memory limit, and Kubernetes kills your pod outright. Exceed your CPU limit, and it just quietly throttles you. These are very different failure modes.”</blockquote><h3>The incident this actually caused</h3><p>Our checkout service started restarting periodically under Black Friday-level traffic — not crashing from an application bug, just getting OOMKilled and restarting, over and over, during exactly the traffic spikes when we needed it most stable. The memory limit had been set based on the service’s typical steady-state usage, observed months earlier when traffic was much lower.</p><p>What we hadn’t accounted for: under high concurrent load, the service’s in-memory request queue grew, connection pooling used more memory to handle more simultaneous connections, and garbage collection pauses meant memory usage spiked higher and stayed elevated longer than it did under light load. The limit that was comfortable in typical conditions became a ceiling we slammed into repeatedly during exactly the conditions that mattered most.</p><h3>The CPU throttling problem is sneakier</h3><p>On a different service, we saw elevated response times under load that didn’t correlate with any resource metric we were watching closely — CPU usage looked fine, well under 100% of the node’s total capacity. What we eventually found was that the service’s CPU limit was being hit and the container was being throttled, even though overall node CPU usage looked healthy, because CPU limits are enforced per-container using a mechanism called CFS quotas, and those quotas get calculated in tiny time slices. A container can be throttled significantly while node-level CPU usage graphs show plenty of headroom, because the throttling is happening at a resolution most dashboards don’t show.</p><p>This was genuinely one of the more counterintuitive things I’ve learned working with Kubernetes — the instinct to check “is the node out of CPU” doesn’t answer the question “is this specific container being throttled,” and the tools that would show you the second thing aren’t part of the default monitoring most teams set up.</p><h3>What we changed</h3><p>We stopped setting limits based on typical usage and started setting them based on observed peak usage under realistic load testing, with meaningful headroom above that peak — not the comfortable-looking numbers that worked fine until they didn’t. For memory specifically, we treated the limit as a safety net for genuine leaks or bugs, not a tight cap meant to optimise resource usage, because the cost of an OOMKill during peak traffic is far higher than the cost of slightly over-provisioning memory.</p><p>We also added CPU throttling metrics to our dashboards specifically, rather than relying on aggregate CPU usage, because that’s the metric that would have caught the second incident hours earlier than we actually caught it.</p><h3>The broader lesson</h3><p>Resource limits are one of those settings that feels like a formality until it isn’t, and the failure modes they create are specifically the kind that show up under exactly the traffic conditions you can least afford them — because that’s when actual usage diverges furthest from whatever assumptions the limits were originally based on. Load testing your limits, not just your application logic, turned out to be one of the higher-leverage things we started doing.</p><p>The limits aren’t just resource management. They’re a promise about how your app behaves under stress. Test the promise before production does.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cd823c584002" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[YAML Fatigue Is Real — And Kubernetes Made It Worse]]></title>
            <link>https://medium.com/@hrk84ya/yaml-fatigue-is-real-and-kubernetes-made-it-worse-7c3ff6a25dcf?source=rss-31fb8ca6c045------2</link>
            <guid isPermaLink="false">https://medium.com/p/7c3ff6a25dcf</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[developer-experience]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[yaml]]></category>
            <dc:creator><![CDATA[Harsh Kumar]]></dc:creator>
            <pubDate>Fri, 31 Jul 2026 01:31:01 GMT</pubDate>
            <atom:updated>2026-07-31T01:31:01.441Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qMnVgOo5P6NVzF2g17eEQw.png" /><figcaption>Image generated with AI</figcaption></figure><h4>I counted once. Our deployment for a single service touched eleven YAML files. Something about that number felt wrong.</h4><p>Early in my current role, I was asked to deploy a small internal tool — nothing complicated, a single service with a database connection and an internal-only endpoint. By the time I was done, I’d written or modified a Deployment, a Service, a ConfigMap, a Secret, an Ingress, a HorizontalPodAutoscaler, a NetworkPolicy, a ServiceAccount, and two RBAC manifests for that service account. Eleven files. For a tool that took less time to actually build than it took to deploy correctly.</p><p>I don’t think this is an unusual experience. I think it’s close to the default experience of working with raw Kubernetes manifests at any real scale, and I think we’ve collectively normalized it in a way that’s worth questioning.</p><h3>Why it happens</h3><p>Kubernetes’ design philosophy is declarative and composable — instead of one big configuration object, you define separate resources that each handle one concern, and Kubernetes reconciles them into a running system. This is a genuinely good design principle in the abstract. Separation of concerns, single-responsibility objects, the ability to modify one aspect of a deployment without touching the others.</p><p>The problem is that the cognitive overhead of this separation falls entirely on the human writing the YAML. Nothing enforces that your Service’s selector actually matches your Deployment’s pod labels — if they drift, you get a working-looking cluster with traffic going nowhere, and you find out from a 500 error rather than a validation step. Nothing catches a Secret referenced in a Deployment that doesn’t actually exist until the pod fails to start. The composability is real, but so is the number of ways the pieces can silently fail to compose correctly.</p><blockquote>“Nothing enforces that your Service’s selector actually matches your Deployment’s labels. If they drift, you find out from a 500 error, not a validation step.”</blockquote><h3>The tools that are supposed to help, and their own costs</h3><p>Helm templates the YAML, so you’re not copy-pasting boilerplate for every service, which genuinely helps — until you’re debugging a templating error inside a chart written by someone who left the company two years ago, staring at Go template syntax embedded inside YAML, trying to figure out why a value isn’t being substituted correctly. Kustomize offers overlays instead of templating, which avoids some of Helm’s complexity but introduces its own mental model of bases and patches that takes real time to internalise.</p><p>Both tools solve real problems. Both also add a layer of indirection between what you write and what actually gets applied to the cluster, which means debugging now involves an extra step of figuring out what the templating actually rendered before you can even start reasoning about why the cluster is behaving the way it is.</p><h3>What actually reduced the fatigue for us</h3><p>Not a tool, mostly — a set of conventions. We built a small internal scaffold that generates the boilerplate for a new service’s manifests from a short config file, covering the RBAC and NetworkPolicy defaults that were nearly identical across every service anyway. This didn’t eliminate YAML. It eliminated the eleven-file experience for the ninety per cent of services that didn’t need anything unusual, and let engineers focus their YAML-writing effort on the ten per cent of configuration that was actually specific to their service.</p><p>We also started treating manifest review with the same rigour as code review, rather than the rubber-stamp treatment YAML often gets because it “isn’t really code.” A surprising number of production issues traced back to config drift that a careful reviewer would have caught — a resource limit that didn’t match what the previous deployment had, a probe path that pointed at an endpoint that no longer existed.</p><h3>The honest takeaway</h3><p>The fatigue is real, and it’s not a personal failing — it’s a predictable consequence of a declarative, composable system with no built-in cross-validation between the pieces. Tools help at the margins. What helps more is treating your manifests as a real, reviewed, tested part of your system rather than a chore to get through so the actual code can ship.</p><p>Eleven files for one small tool still sounds like a lot to me. I’ve just gotten better at making sure all eleven agree with each other.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7c3ff6a25dcf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[You Probably Don’t Need a Service Mesh (But Here’s When You Do)]]></title>
            <link>https://medium.com/@hrk84ya/you-probably-dont-need-a-service-mesh-but-here-s-when-you-do-56d0fc36d6d4?source=rss-31fb8ca6c045------2</link>
            <guid isPermaLink="false">https://medium.com/p/56d0fc36d6d4</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[service-mesh]]></category>
            <category><![CDATA[istio]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[architecture]]></category>
            <dc:creator><![CDATA[Harsh Kumar]]></dc:creator>
            <pubDate>Tue, 28 Jul 2026 01:31:01 GMT</pubDate>
            <atom:updated>2026-07-28T01:31:01.453Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*l-S3v3qsVTA6gWjbVAkDsw.png" /><figcaption>Image generated with AI</figcaption></figure><h4>We spent three weeks evaluating Istio for a system with six services. Here’s what we learned about when a mesh actually earns its complexity.</h4><p>A staff engineer on my team floated the idea of adopting Istio during a planning meeting. We had six services running in our cluster. The pitch was reasonable-sounding: better observability into service-to-service traffic, automatic mutual TLS between services, retry and circuit-breaking logic without having to build it into every service individually. All real benefits. All things a service mesh genuinely provides.</p><p>We spent about three weeks evaluating it before deciding not to adopt it, at least not yet. I want to explain why, because I think the reasoning generalises better than the specific decision does.</p><h3>What a service mesh actually gives you</h3><p>A service mesh works by deploying a proxy — typically Envoy — alongside every pod, intercepting all network traffic in and out of that pod. This sidecar pattern lets the mesh handle cross-cutting concerns uniformly across every service without each service needing to implement them individually: encryption between services, fine-grained traffic routing for canary deployments, automatic retries with backoff, detailed metrics on every request between every pair of services.</p><p>These are genuinely valuable capabilities, and at a certain scale — dozens or hundreds of services, multiple teams deploying independently, real need for fine-grained traffic control — they become close to essential. Trying to build consistent mTLS, retries, and observability into every service by hand, across a large organisation, is a worse problem than the mesh’s complexity.</p><blockquote>“A service mesh solves organisational problems as much as technical ones. We had six services and one team. We didn’t have the organisational problem yet.”</blockquote><h3>What it costs, concretely</h3><p>Every pod now runs an extra container, which means more memory and CPU overhead across your entire cluster — not huge per-pod, but it adds up, and at our scale it was a genuinely noticeable percentage increase in cluster resource usage for benefits we weren’t yet using. Every request now has an extra network hop through the local proxy, adding latency that’s small per-hop but real in aggregate for latency-sensitive paths.</p><p>And then there’s the operational complexity, which was the part that actually changed our minds. Istio has its own control plane, its own upgrade cycle, its own failure modes, and its own learning curve on top of Kubernetes’ existing learning curve. When something breaks in a mesh, you now have to figure out whether the problem is in your application, in Kubernetes networking, or in the mesh’s traffic management layer — three places to check instead of two, for a team that was already stretched thin understanding two.</p><h3>The actual decision framework</h3><p>The question that mattered most wasn’t “would a mesh help us” — the honest answer to that is almost always yes, in the sense that more observability and more automatic reliability features are always helpful in the abstract. The question that mattered was whether the specific problems a mesh solves were problems we actually had right now, versus problems we might have eventually.</p><p>We didn’t have multiple teams stepping on each other’s traffic routing. We didn’t have a security requirement mandating mTLS between internal services yet. We didn’t have complex canary or traffic-splitting needs — we deployed the same way to all users. What we had was six services, one team, and a codebase small enough that we could reason about the whole system without a specialised tool to help us see across it.</p><h3>When I’d actually reach for one</h3><p>If your organisation has grown past the point where a handful of engineers can hold a mental model of how services talk to each other. If you have a genuine compliance requirement for encryption in transit between every internal service. If you’re doing frequent canary releases and need traffic-splitting capabilities that would otherwise require building bespoke tooling. If you have enough services that consistent, centralised observability into service-to-service calls is worth more than the operational overhead of running the mesh itself.</p><p>None of these was true for us yet. We wrote this reasoning down, revisited it six months later when the service count had roughly doubled, and made a different decision at that point — one that made a lot more sense with the actual scale in front of us instead of the scale we were preparing for.</p><p>The mesh isn’t wrong. Adopting it before you need it is. Know which one you’re doing.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=56d0fc36d6d4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kubernetes Networking Explained Without the Hand-Waving]]></title>
            <link>https://medium.com/@hrk84ya/kubernetes-networking-explained-without-the-hand-waving-b9aac148b06f?source=rss-31fb8ca6c045------2</link>
            <guid isPermaLink="false">https://medium.com/p/b9aac148b06f</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[networking]]></category>
            <dc:creator><![CDATA[Harsh Kumar]]></dc:creator>
            <pubDate>Sat, 25 Jul 2026 03:31:01 GMT</pubDate>
            <atom:updated>2026-07-25T03:31:01.705Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*omL9-l4QWq1-tMA1qRHArg.png" /><figcaption>Image generated with AI</figcaption></figure><h4>Most explanations either drown you in RFC references or wave vaguely at “the CNI handles it.” I wanted the version in between.</h4><p>When I first tried to understand Kubernetes networking, I read three different explanations and came away with three different levels of confidence, none of them earned. One was so abstract it could have described any distributed system. Another dove straight into iptables rules and CNI plugin internals before I understood what problem any of it was solving. What I actually needed was the middle layer: what is Kubernetes networking trying to guarantee, and what does it take to make that guarantee true.</p><p>Here’s the version I wish someone had given me, built from what I’ve actually had to debug rather than what a spec document says should happen.</p><h3>The one guarantee everything else is built on</h3><p>Kubernetes networking has a foundational rule: every pod gets its own IP address, and every pod can reach every other pod’s IP directly, without network address translation, regardless of which node either pod is running on. This sounds simple. It’s actually the thing that makes almost everything else about Kubernetes possible — pods can be scheduled anywhere, moved anywhere, scaled up or down, and the network model doesn’t change underneath them.</p><p>This guarantee is not provided by Kubernetes itself. It’s provided by whatever CNI (Container Network Interface) plugin you’ve installed — Calico, Cilium, Flannel, and others. Kubernetes defines the contract; the CNI plugin implements it. This is the detail that confused me longest: Kubernetes doesn’t actually do networking. It delegates networking to a plugin and assumes the plugin holds up its end of the deal.</p><blockquote>“Kubernetes doesn’t actually do networking. It delegates networking to a plugin and assumes the plugin holds up its end of the deal.”</blockquote><h3>Why pod IPs alone aren’t enough</h3><p>Pod IPs are useful but unstable — pods die and get replaced with new IPs constantly, especially under autoscaling or rolling deployments. If your checkout service tried to talk directly to inventory-service-pod-7f8c9, that pod might not exist five minutes from now. This is what Services solve: a stable virtual IP and DNS name that sits in front of a set of pods and load-balances across whichever ones are currently alive.</p><p>When you create a Service, kube-proxy (running on every node) sets up rules — historically iptables, increasingly IPVS or eBPF depending on your CNI — that intercept traffic to the Service’s virtual IP and redirect it to one of the healthy backing pods. This redirection happens at the node level, which is why a networking issue can sometimes be node-specific in ways that are genuinely confusing to debug: the same request might succeed from one node and hang from another if that node’s proxy rules are stale or broken.</p><h3>DNS is doing more work than people realize</h3><p>Every Service gets a DNS name automatically, resolved by CoreDNS running inside the cluster. This is the part of Kubernetes networking that I’ve seen cause the most real incidents, mine included — because DNS resolution sits on the critical path of nearly every internal request, but it’s rarely monitored with the same rigor as the services actually doing the work. If CoreDNS is under-provisioned or under memory pressure, you get exactly the kind of intermittent, hard-to-reproduce latency that looks like a mystery until you specifically go looking for it.</p><h3>Where Network Policies come in</h3><p>By default, every pod can talk to every other pod, cluster-wide, with no restriction. This is convenient for getting started and genuinely alarming from a security standpoint once you think about it — a compromised pod in one namespace can freely reach a database pod in a completely unrelated namespace unless something stops it.</p><p>NetworkPolicies are that something — rules that restrict which pods can talk to which other pods, based on labels and namespaces. The catch, which took me a while to internalise, is that NetworkPolicies only work if your CNI plugin actually implements them. Some do, some don’t, and assuming they’re enforced when they’re not is a quiet, dangerous gap.</p><h3>Ingress: the part most tutorials start with, and probably shouldn’t</h3><p>Ingress controllers handle traffic coming from outside the cluster into your services — routing based on hostname or path, usually terminating TLS along the way. It’s the most visible piece of Kubernetes networking, which is why tutorials often start there. I think this is backwards pedagogically, because Ingress makes a lot more sense once you already understand that it’s really just a specialised entry point into the same Service and pod networking model underneath.</p><p>Once you see the whole picture — pod IPs as the foundation, Services for stability, DNS for discovery, NetworkPolicies for restriction, Ingress for external entry — the pieces stop being a memorised list and start being a system you can actually reason about when something breaks.</p><p>I still don’t know all of it. But I know enough now to know where to look first, which turns out to be most of the job.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b9aac148b06f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Debugged a Production Kubernetes Outage That Took 14 Hours to Find]]></title>
            <link>https://medium.com/@hrk84ya/how-i-debugged-a-production-kubernetes-outage-that-took-14-hours-to-find-82086b1a9ca8?source=rss-31fb8ca6c045------2</link>
            <guid isPermaLink="false">https://medium.com/p/82086b1a9ca8</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Harsh Kumar]]></dc:creator>
            <pubDate>Tue, 21 Jul 2026 03:31:01 GMT</pubDate>
            <atom:updated>2026-07-21T03:31:01.839Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LXoL6_-QexdiTDqJO6rxRw.png" /><figcaption>Image generated with AI</figcaption></figure><h4>The dashboards said everything was healthy. Users said otherwise. It took most of a day to find out both were right.</h4><p>It was a Tuesday, three months into my role after converting from intern to full-time. Around 11 am, a support ticket came in: a customer couldn’t complete checkout. Then another. By 11:20, the number was climbing, but our dashboards showed all green — pod health checks passing, CPU and memory normal, response times within range. The classic, uncomfortable gap between what the monitoring says and what users are experiencing.</p><p>I want to walk through this in order, because the order is the actual lesson. The fix, when we found it, took ten minutes to apply. Finding it took fourteen hours and involved being wrong about the cause at least four separate times.</p><h3>Hour 1: The obvious suspects, all cleared</h3><p>We checked the checkout service pods first — the obvious place to start, since that’s where the failures were reported. All pods were Running, all readiness probes passing, no recent deployments in the last 48 hours. We checked the database — connection pool looked normal, query latency was flat. We checked the payment provider’s status page. Nothing. Everything that should have told us something was wrong was telling us everything was fine, while a growing number of real customers could not check out.</p><p>This is the part of debugging that doesn’t get talked about enough: the first hour is mostly ruling things out, and ruling things out feels like failure even though it’s actually progress. By hour two, we had eliminated the checkout service itself, the database, and the external payment API. Which meant the problem was somewhere in between.</p><h3>Hours 2 through 5: Chasing a red herring</h3><p>Someone noticed that error rates correlated loosely with a spike in traffic to a completely unrelated service — an internal analytics pipeline that had also seen a load increase that morning. We spent close to three hours investigating whether that service was somehow starving shared cluster resources, checking node-level CPU and memory across the shared node pool, looking at whether the analytics pods were being scheduled onto the same nodes as checkout pods and causing contention.</p><p>It was a reasonable theory. It was also wrong. The correlation was coincidental — both had upticks around the same time because it was lunch hour traffic in two different senses. I mention this because most outage retrospectives I’d read before this made debugging sound linear: check A, find the problem, fix it. The actual experience is closer to sonar in fog — you send out a theory, it comes back negative, and you’ve at least learned the shape of the water even though you still don’t know where the submarine is.</p><h3>Hour 6: The detail that mattered</h3><p>A teammate, going back through the checkout pod logs with fresh eyes, noticed something we’d all glossed over: a small number of requests were timing out specifically when calling an internal inventory-check service — not failing, timing out, which meant the request was hanging rather than erroring immediately. This was different enough from what we’d been looking at that it reopened the investigation in a new direction.</p><p>We looked at the inventory service. Its pods were healthy. Its response times, according to its own service-level metrics, were fine. But those metrics were measured from inside the pod, at the application layer — they wouldn’t show a problem that existed at the network layer, between the checkout service and the inventory service specifically.</p><h3>Hours 7 through 11: Finding the actual mechanism</h3><p>This part was slow and involved a lot of kubectl exec sessions and curl commands run from inside various pods to isolate exactly where the latency was being introduced. Eventually we found it: intermittent DNS resolution delays inside the cluster, specifically for the inventory service’s ClusterIP. Not all the time — maybe one in twenty requests — which explained why it hadn’t shown up in aggregate health checks but was absolutely showing up for real customers hitting checkout at scale.</p><p>The root cause, once we found it, was almost anticlimactic: CoreDNS, running with default resource limits, had been getting throttled under the increased traffic that morning, causing a small but consistent percentage of DNS lookups inside the cluster to time out and retry. The retries added latency. The latency, compounded across a checkout flow that made several internal service calls, was enough to push a meaningful fraction of checkouts past our client-side timeout.</p><h3>Hour 14: The fix and the aftermath</h3><p>We increased CoreDNS’s resource limits and added a horizontal pod autoscaler for it, since it had never occurred to anyone that our own internal DNS was a scaling bottleneck. The fix took about ten minutes to deploy. Checkout success rates returned to normal within another five.</p><p>What I took from this, beyond the specific fix: our monitoring was built almost entirely around service-level health, and almost nothing around the connective tissue between services — DNS, network policies, service mesh if you have one. The things that fail invisibly are rarely the services themselves. They’re the plumbing everyone assumes just works.</p><p>We added CoreDNS latency to our dashboards that week. It’s one of the first things I check now when something feels wrong, but everything says it’s fine.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=82086b1a9ca8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Difference Between Knowing Kubernetes and Understanding Kubernetes]]></title>
            <link>https://medium.com/@hrk84ya/the-difference-between-knowing-kubernetes-and-understanding-kubernetes-f79b8ba32b75?source=rss-31fb8ca6c045------2</link>
            <guid isPermaLink="false">https://medium.com/p/f79b8ba32b75</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[infrastructure]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Harsh Kumar]]></dc:creator>
            <pubDate>Sat, 18 Jul 2026 03:31:01 GMT</pubDate>
            <atom:updated>2026-07-18T03:31:01.511Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zNCCUEasJz2ZfxOXbBoAVA.png" /><figcaption>Image generated with AI</figcaption></figure><h4>I could recite the architecture diagram after a week. It took me a production incident to actually understand what any of it meant.</h4><p>By the end of my first week around a real Kubernetes cluster, I could draw the architecture diagram from memory. Control plane, API server, etcd, scheduler, controller manager. Worker nodes, kubelet, kube-proxy, the container runtime. I could explain what a pod was, how it differed from a container, how a deployment managed replica sets, how a service provided a stable network identity for a set of pods that could come and go. I felt, honestly, pretty good about how fast I’d picked it up.</p><p>Then a pod started restarting in a loop in staging, and I had absolutely no idea what to do.</p><h3>What “knowing” actually gets you</h3><p>The diagram-level knowledge is real, and it’s not nothing — you need it as scaffolding before anything else makes sense. But it’s declarative knowledge, the kind you can get from documentation and a few good YouTube videos. It tells you what the pieces are called and roughly how they relate. It does not tell you what it feels like when one of those pieces is lying to you, which happens more often than the documentation suggests.</p><p>The pod restart loop was a good example. `kubectl get pods` showed CrashLoopBackOff. I knew what that meant in the abstract — the container was exiting, and Kubernetes was backing off on restart attempts. What I didn’t have was the instinct for where to look next. I checked the logs. They showed nothing useful, because the container was crashing before it got far enough to log the actual error. I stared at that for longer than I want to admit.</p><blockquote>“Declarative knowledge tells you what the pieces are called. It doesn’t tell you what it feels like when one of them is lying to you.”</blockquote><h3>What understanding actually looks like</h3><p>A senior engineer walked over, looked at the same output I’d been staring at, and immediately checked the previous container’s logs with kubectl logs --previous, because she knew crash loops usually meant the useful error was in the last attempt, not whatever fragment made it into the current one. That single command reflected something I didn&#39;t have: a mental model built from having debugged this exact situation enough times that the diagnostic path was automatic.</p><p>The error turned out to be a missing environment variable that had been fine in the previous deployment because a ConfigMap update hadn’t been rolled out to this particular revision yet. Understanding this required knowing not just what a ConfigMap was, but how config changes propagate — or don’t — to already-running pods, and why a deployment might reference an old version of config until something forces a rollout. None of this was hard to explain once I saw it. All of it was invisible from the architecture diagram.</p><h3>The pattern I noticed after that</h3><p>Every real understanding I’ve built about Kubernetes has come from a version of this same experience: something breaks, the documentation doesn’t quite cover the specific case, and I have to actually trace through what the system is doing rather than what I assumed it was doing. Resource limits that seemed reasonable in isolation but caused OOM kills under real load. A liveness probe that was too aggressive and kept killing healthy pods during a slow startup. A DNS issue inside the cluster that took an afternoon to trace back to CoreDNS being resource-starved on a node under memory pressure.</p><p>None of these were things I could have learned from reading more documentation, though the documentation made a lot more sense to me after I’d lived through the incident it was describing. The order matters. Reading first and experiencing second builds a shallow model. Experiencing first — even a small, contained version of it — and then reading gives the reading somewhere to land.</p><h3>What I’d tell someone starting out</h3><p>Set up a cluster on your own machine — kind or minikube works fine — and deliberately break things. Misconfigure a resource limit and watch what happens under load. Kill a node and watch how the scheduler responds. Write a bad liveness probe and see what it does to your pods. The goal isn’t to memorise the fix. It’s to build the pattern-matching that only comes from watching cause and effect play out, so that when it happens in production, and the timeline actually matters, you’re not starting from zero.</p><p>The architecture diagram gets you in the room. Only the incidents actually teach you the system.</p><p>I still keep that diagram somewhere for reference. I just don’t mistake having memorised it for actually knowing what I’m doing anymore.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f79b8ba32b75" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kubernetes Is Powerful. It’s Also Way Too Complex for Most Teams That Use It.]]></title>
            <link>https://medium.com/@hrk84ya/kubernetes-is-powerful-its-also-way-too-complex-for-most-teams-that-use-it-6289d226aabd?source=rss-31fb8ca6c045------2</link>
            <guid isPermaLink="false">https://medium.com/p/6289d226aabd</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[infrastructure]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[productivity]]></category>
            <dc:creator><![CDATA[Harsh Kumar]]></dc:creator>
            <pubDate>Thu, 16 Jul 2026 05:20:27 GMT</pubDate>
            <atom:updated>2026-07-16T05:20:27.988Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*33erHY7C-6_zugGWt76D1w.png" /><figcaption>Image generated with AI</figcaption></figure><h4>I watched a five-person startup adopt Kubernetes because a blog post told them to. Here’s what actually happened.</h4><p>During my second internship, the team I joined had just finished migrating from a couple of EC2 instances running Docker Compose to a full Kubernetes cluster. Six people. One production application. A staging environment. And now, an EKS cluster with three node groups, a Helm chart repo, an ingress controller, cert-manager, and a Prometheus stack that alone probably had more moving parts than the actual product being served.</p><p>I remember asking, in my first week, why we needed Kubernetes for an app that handled maybe two hundred requests a minute at peak. The answer I got was some version of “it’s what everyone uses” and “it’ll scale better later.” Eight months later, when I left that internship, the app still handled roughly the same load. Two people on the team had become de facto Kubernetes specialists, spending a meaningful chunk of their week on cluster maintenance instead of product work. Nobody had explicitly decided this trade-off was worth it. It just happened, one YAML file at a time.</p><h3>The gap between the pitch and the reality</h3><p>Kubernetes is genuinely excellent at what it’s built for: orchestrating large numbers of containers across many machines, handling failures automatically, scaling workloads dynamically, and giving large engineering organisations a consistent deployment model across dozens or hundreds of services. If you’re running that kind of scale, the complexity is buying you something real.</p><p>Most teams that adopt it are not running that kind of scale. They’re running a handful of services, sometimes a single service, and they’ve adopted the tool that solves problems they don’t have yet, at the cost of complexity they’re definitely dealing with right now. The pitch focuses on the destination — infinite scale, self-healing infrastructure, cloud portability. It says very little about the toll of getting there, which is where most teams actually live.</p><blockquote>“The pitch focuses on the destination. It says very little about the toll of getting there, which is where most teams actually live.”</blockquote><h3>What the complexity actually costs</h3><p>It’s not just the learning curve, though that’s real — I spent weeks during that internship just building a working mental model of how a request flows from ingress to pod. It’s the ongoing tax. Cluster upgrades that need to happen on a schedule whether or not anyone has time for them. Node pool sizing decisions that require understanding workload patterns nobody has fully documented. YAML sprawl across dozens of files that need to stay consistent with each other, with no compiler to catch you when they don’t.</p><p>And it’s the incident surface. A Kubernetes cluster introduces new failure modes that don’t exist in simpler deployments — misconfigured resource limits causing silent OOM kills, DNS resolution issues inside the cluster, networking policies that block traffic nobody meant to block. I watched a senior engineer on that team lose an entire afternoon to a service that couldn’t reach another service, only to discover the issue was a misconfigured NetworkPolicy that had been copy-pasted from a tutorial eight months earlier and never fully understood by the person who added it.</p><h3>The honest question nobody asks early enough</h3><p>Do you actually have the scale, team size, or operational maturity that makes this complexity worth it? For a lot of teams, the honest answer is no — not yet, and possibly not for years. A well-configured deployment on a managed platform, or even a couple of well-monitored VMs behind a load balancer, would serve the same traffic with a fraction of the operational overhead and a much shorter list of things that can silently break.</p><p>The reason teams adopt Kubernetes anyway is rarely a careful capacity analysis. It’s usually some combination of resume-building, cargo-culting what larger companies do, and a genuine but premature optimism about future growth. None of these is unreasonable motivations exactly. They’re just not the same as “we need this.”</p><h3>When it’s actually the right call</h3><p>I don’t want to overcorrect into “Kubernetes is always wrong for small teams,” because that’s not true either. If you’re already running multiple services that need independent scaling, if you have engineers who already know Kubernetes well and the learning curve is sunk cost, or if you’re building toward a scale you can already see coming with reasonable confidence — it can be the right tool even for a smaller team.</p><p>The distinction is whether the decision was made deliberately, weighing the actual operational cost against the actual current need, or whether it happened because Kubernetes is the assumed default in a lot of engineering culture right now. Most of the trouble I’ve seen comes from the second path.</p><p>The tool isn’t the problem. The unexamined adoption is. Ask what you actually need before you ask what everyone else is using.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6289d226aabd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Vibe Coding Is Not the Future. But It’s Not Nothing Either.]]></title>
            <link>https://medium.com/@hrk84ya/vibe-coding-is-not-the-future-but-its-not-nothing-either-6c7b714a5034?source=rss-31fb8ca6c045------2</link>
            <guid isPermaLink="false">https://medium.com/p/6c7b714a5034</guid>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Harsh Kumar]]></dc:creator>
            <pubDate>Fri, 15 May 2026 03:01:01 GMT</pubDate>
            <atom:updated>2026-05-15T03:01:01.435Z</atom:updated>
            <content:encoded><![CDATA[<h4>The honest take on what happens when you describe software in plain English and press go.</h4><p>“Vibe coding” — the practice of generating code almost entirely through natural language prompts, without reading much of what gets produced — has been having a moment. It’s also been generating the kind of discourse that tends to happen when something is genuinely new: one camp insisting it changes everything, another insisting it’s dangerous nonsense, and a quieter middle wondering why we can’t just be accurate about what it is and isn’t.</p><p>I’ve been in that quieter middle. Here’s what I’ve actually observed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*f-9Rz3NEFi1fZ16a" /><figcaption>Photo by <a href="https://unsplash.com/@hdbernd?utm_source=medium&amp;utm_medium=referral">Bernd 📷 Dittrich</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>What it actually is</h3><p>Vibe coding, at its most literal, is describing what you want in natural language, having a model generate the implementation, and moving forward without reviewing the generated code in much detail. The “vibe” part is real — you’re steering by feel and outcome rather than by reading instructions. It can work. It works in specific circumstances. Understanding those circumstances is the whole thing.</p><p>It works best when the failure mode is visible and cheap. If you’re building a personal tool, a proof of concept, or an isolated prototype, and the way you know it’s wrong is that it doesn’t do the thing when you run it — then the feedback loop is tight enough that not reading the code closely is an acceptable tradeoff for speed. You run it, it breaks, you describe the break, you iterate. The generated code is almost irrelevant as long as the outcome converges.</p><p>It works worse when the failure mode is invisible and expensive. Production systems. Code that handles money. Anything where “works in testing” and “works in production under load” are two different things. Anything where a security vulnerability is the failure mode, because security failures tend to be silent until they’re catastrophic. In these contexts, not reading the code is not a workflow choice — it’s a way of not doing your job.</p><blockquote>You’re steering by feel and outcome rather than by instructions. It works. In specific circumstances. Understanding those circumstances is the whole thing.</blockquote><h3>The criticism that misses the point</h3><p>The most common critique of vibe coding is that it produces bad code. This is true in a specific sense and misleading in a general one. It produces code with properties that a careful developer might not choose: inconsistent patterns, missing edge case handling, and abstractions that made sense for the generation context but don’t generalise well. These are real problems.</p><p>But “produces bad code” implies a comparison to an alternative, and the alternative is not always hand-crafted code by a skilled developer. Sometimes the alternative is a weekend project that never gets built because writing it from scratch would have taken two weeks that the person doesn’t have. A working prototype with rough edges, that you can learn from and decide whether to invest in further, is not nothing. It might be more valuable than the perfect version that doesn’t exist yet.</p><p>The appropriate level of rigour depends on what you’re building and what the consequences of being wrong are. This should be obvious. Somehow, it keeps getting lost in the vibe coding discourse.</p><h3>The criticism that doesn’t miss the point</h3><p>If you’re learning to code and you use vibe coding as your primary method, you are not learning to code. You’re learning to describe outcomes and evaluate results, which is a real skill, but it’s not the same skill. The model between “I described this” and “this code exists” is doing something you don’t understand, and over time, that gap matters. You won’t know why things break in the ways they break. You won’t have the mental models to debug the non-obvious failures. You’ll be able to build things until you hit a problem the model can’t solve, and then you’ll be stuck without the foundation to proceed.</p><p>This is a real concern for people entering software development right now. The temptation to skip the hard parts is understandable. The hard parts are, in fact, hard. But they’re what make the model’s output legible to you. Without them, you’re dependent on a tool in a way that compounds over time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Hkdu6S-R8uipXXgC" /><figcaption>Photo by <a href="https://unsplash.com/@haky?utm_source=medium&amp;utm_medium=referral">Shamin Haky</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>The part that’s genuinely new</h3><p>What’s actually interesting about vibe coding — the part worth taking seriously rather than dismissing — is that it changes who can make software. Not at the production level for complex systems. But a person with no programming background who has a clear mental model of a problem they want to solve can now produce a working tool that addresses that problem. This was not true five years ago.</p><p>The implications of that are still playing out. Internal tools inside companies, built by domain experts who understand the problem but couldn’t previously build the solution. Personal automations. Small utilities. Exploratory prototypes that help someone understand whether an idea is worth investing in. The surface area of “people who can make something computational” has expanded, and that’s not nothing.</p><p>The future of software development is not everyone vibe-coding their way to production systems. That’s a bad outcome. But the future also isn’t the status quo, where building software requires years of specialised training before you can produce anything useful. Something in between is probably where this lands, and being honest about both the uses and the limits gets us there faster than the binary takes do.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6c7b714a5034" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>