<?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 Yoshith Kesari on Medium]]></title>
        <description><![CDATA[Stories by Yoshith Kesari on Medium]]></description>
        <link>https://medium.com/@yoshithkesari?source=rss-c9373a907960------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*mK0ZAYoMNq2cpwOD</url>
            <title>Stories by Yoshith Kesari on Medium</title>
            <link>https://medium.com/@yoshithkesari?source=rss-c9373a907960------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 20:55:33 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@yoshithkesari/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[GLOW.]]></title>
            <link>https://medium.com/@yoshithkesari/glow-3f1bbc149fe0?source=rss-c9373a907960------2</link>
            <guid isPermaLink="false">https://medium.com/p/3f1bbc149fe0</guid>
            <category><![CDATA[personal-branding]]></category>
            <category><![CDATA[personal-growth]]></category>
            <dc:creator><![CDATA[Yoshith Kesari]]></dc:creator>
            <pubDate>Fri, 16 Oct 2026 18:28:34 GMT</pubDate>
            <atom:updated>2026-10-16T18:28:34.072Z</atom:updated>
            <content:encoded><![CDATA[<h3>Grow. Larp. Outwork. Win.</h3><blockquote><em>A signature framework by </em><strong><em>Yoshith</em></strong><em>.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/961/1*AQkZP3FdaHj0Z0uNMHRe2A.png" /><figcaption>Yoshith’s signature framework.</figcaption></figure><h3>GLOW?</h3><p>Everyone has a portfolio now.</p><p>Projects. Skills. Certificates. A profile picture with suspiciously good lighting.</p><p>Open ten of them, and you’ll meet ten “passionate problem solvers.” Same layout. Same energy. Different font, maybe.</p><p>A portfolio shows what you’ve done. But what represents the thinking behind it?</p><p>That’s where GLOW comes in.</p><p>GLOW is my signature. My philosophy. The identity behind my work.</p><p>Four words. Four principles. One name I want you to remember.</p><p>It’s not another guide on how to become successful. The internet has plenty of those, and somehow, they all end with a link to a course.</p><p>This is how I think, how I operate, and how I approach the things I choose to build and strengthens my Personal Branding.</p><h3>The Four Principles</h3><h3>G: Grow</h3><p>Grow in your mind before you grow in reality.</p><p>Most people decide what they can achieve based on what they can do today. Today’s version of me is still loading, so I’m not letting him decide the limits of my future.</p><p>I’m not pretending limitations don’t exist. I just don’t call them permanent before I’ve tested them.</p><p>Reality will humble you eventually. No need to do its job for it.</p><h3>L: LARP</h3><p>Live Action Role-Playing. Yes, really. Put the foam sword down.</p><p>Live with the assumption that you can become the person you’re aiming to be. Then think, act, learn, and build accordingly.</p><p>It doesn’t mean faking skills you don’t have. We’re building an identity, not a criminal case.</p><p>It means not waiting until you feel ready.</p><p>Spoiler: “ready” never sends an invitation.</p><h3>O: Outwork</h3><p>You know the rabbit and the tortoise. The usual lesson is “hard work beats talent.”</p><p>My interpretation is different.</p><p>What if the tortoise wasn’t just hardworking? What if he was <strong>obsessed</strong> with reaching the finish line?</p><p>The rabbit had the speed. The tortoise had the destination.</p><p>Outwork means being so committed to the goal that when the excitement fades, when nobody’s watching, and when the work gets boring, you keep moving anyway.</p><p>And no, putting “sleep is for the weak” in your bio doesn’t count.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pESGQni9vCjyoNo6dCs_3Q.png" /><figcaption>GLOW</figcaption></figure><h3>W: Win</h3><p>I’m not going to tell you what winning looks like.</p><p>I’m still busy with the OUTWORK part. 💀</p><p>But if you’re confident about your own definition of winning,</p><p><strong>let’s meet at the finish line.</strong></p><h3>The Signature</h3><p>Projects change. Skills evolve. Opportunities come and go.</p><p>GLOW is what connects them.</p><p>It’s not a title I put beside my name. It’s the identity I’m building through my work.</p><p>And if, someday, you hear the word GLOW and Yoshith is the first name that comes to mind, then you know exactly what this was about.</p><p>GLOW is Yoshith’s work. Yoshith’s philosophy. Yoshith’s signature.</p><p>The name is here. The work continues.</p><p><strong>GLOW.</strong> Grow. LARP. Outwork. Win.</p><p>The work behind GLOW lives in my personal branding.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3f1bbc149fe0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MCP Isn’t the New API. Stop Saying That.]]></title>
            <link>https://medium.com/@yoshithkesari/mcp-isnt-the-new-api-stop-saying-that-d0130679fe8c?source=rss-c9373a907960------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0130679fe8c</guid>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[api]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[anthropic-claude]]></category>
            <dc:creator><![CDATA[Yoshith Kesari]]></dc:creator>
            <pubDate>Tue, 29 Sep 2026 19:06:35 GMT</pubDate>
            <atom:updated>2026-09-29T19:06:35.082Z</atom:updated>
            <content:encoded><![CDATA[<p>Somebody on LinkedIn told you APIs are dead. Somebody on YouTube told you MCP is “the future of AI” in a thumbnail with a glowing brain on it. Somebody in your team standup used the word “protocol” four times and nobody stopped them to ask what they meant.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/799/1*Hw0_RkX-5cfBz0C5f3KCzQ.png" /><figcaption>MCP vs API</figcaption></figure><p>None of them were right, and none of them were wrong enough to be interesting. Here’s the actual answer, with the humor left in and the nonsense taken out.</p><h3>What is an API?</h3><p>An API — <strong>Application Programming Interface</strong>, a name so charismatic it should come with a warning label — is a fixed contract. One piece of software asks another for something specific. It gets something specific back. No creativity allowed, and that’s the entire point.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_YPqv9S1JC9CxTrx-DeLaw.png" /><figcaption>API Mechanism</figcaption></figure><p>Picture a restaurant. You don’t storm the kitchen and negotiate with the chef about your feelings on cilantro. You pick from a menu, the kitchen does its job, and a plate shows up that matches what you asked for. Your weather app isn’t secretly a meteorologist — it politely asks a weather company, <em>“what’s the weather in Chennai?”</em>, and gets handed back:</p><pre>{ &quot;temperature&quot;: 31, &quot;condition&quot;: &quot;sunny&quot; }</pre><p>That’s it. That’s an API call. Deeply unglamorous, extremely load-bearing for literally everything your phone does.</p><p>Here’s the actual problem, the one nobody puts in the thumbnail: <strong>every service writes its own menu, in its own handwriting, in its own font, presumably out of spite.</strong> Stripe’s API doesn’t look like Slack’s API, which doesn’t look like your company’s fifteen-year-old internal system that only Kevin understood, and Kevin left in 2019, and nobody has dared touch that codebase since. Ten services means ten menus, memorized from scratch, every single time, forever.</p><p>Developers have a name for this specific flavor of suffering: the <strong>M×N problem</strong>. M apps, N services, potentially M×N custom integrations — none of them reusable, all of them somebody’s Tuesday afternoon. It’s not broken. It’s just exhausting at scale, like assembling IKEA furniture for a living, except the instructions are different every time and occasionally written by Kevin.</p><h3>What is MCP?</h3><p>MCP — <strong>Model Context Protocol </strong>— is <strong>Anthropic’s answer</strong> to one specific, narrower, much less sexy question than the hype implies: <strong>why is every AI model relearning every single menu, independently, forever, like it’s the first AI model to ever exist?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UZAF_dKEafE8Fo-0x3TKqw.png" /><figcaption>MCP Mechanism</figcaption></figure><p>Introduced in November 2024, MCP is the shared language. An <strong>MCP server</strong> is one restaurant training exactly one waiter to speak it. Train that waiter once, and <em>any</em> AI model fluent in MCP — Claude, ChatGPT, Gemini, whichever model shows up to the party next year — walks in and orders immediately. No private lessons. No bespoke integration built at 2am by someone who will quit six months later.</p><pre>AI application → MCP → MCP server → Tool / API / Database / System</pre><p>The part everyone conveniently forgets to mention on LinkedIn: <strong>the API never left.</strong> The MCP server almost always sits directly on top of it, as a standardized front door bolted onto the same kitchen that was already there:</p><pre>AI application → MCP → MCP server → Calendar API → Calendar service</pre><p>MCP didn’t fire the chef. It just means the traveler doesn’t need a personal orientation session before they’re allowed to eat.</p><p>And before you assume this is 2024’s blockchain — all hype, zero receipts — here’s the part that’s actually, annoyingly, real: within about a year, MCP’s SDKs were pulling roughly 97 million downloads a month. OpenAI, Google DeepMind, and Microsoft all built support for it, which is rare enough that it should probably be studied. And by late 2025, Anthropic handed the whole protocol over to a neutral body — the Agentic AI Foundation under the Linux Foundation, co-founded with Block and OpenAI — specifically so it couldn’t quietly become “one company’s proprietary standard that everyone else has to beg to use.” That’s not vaporware behavior. That’s someone deliberately giving away the thing that would’ve made them money to keep, which in tech is basically a miracle.</p><p>Yes, it’s the “USB-C of AI.” Yes, everyone says that. Yes, it’s still accurate: USB-C didn’t invent charging, it just ended the era of seventeen mismatched cables in a drawer. MCP is doing the same thing, except the drawer is every AI lab quietly building the same integration in isolation, forever, for no reason.</p><h3>MCP vs API?</h3><p><strong>API</strong> <strong>MCP</strong> <strong>What it actually is</strong> A specific contract between two systems A shared protocol letting AI models use <em>many</em> systems <strong>Who writes it</strong> Every service, alone, in isolation One standard, reused everywhere <strong>Built for</strong> Any software talking to any software AI models specifically, deciding what to call mid-conversation <strong>Relationship</strong> The engine under the hood A standardized layer bolted <em>on top of</em> that engine <strong>The question it answers</strong> “How do I talk to this one thing?” “Why am I rebuilding that answer every single time?”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1VaA7tOAzt4uwWYhcg-AXg.png" /><figcaption>The actual API vs MCP</figcaption></figure><p>The one-liner worth stealing: <strong>an API is one restaurant’s private menu. MCP is a universal waiter who already knows how to work any restaurant that bothered to train them.</strong></p><p>Nobody is choosing between these two things, because they were never actually competing. Anyone telling you “APIs are dead, MCP replaced them” has, statistically, never shipped either one — and can be safely muted, unfollowed, and gently pitied.</p><p><em>Sources: Anthropic (Model Context Protocol announcement and 2026 ecosystem updates); independent 2026 reporting on MCP adoption.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0130679fe8c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Are We Really in the Singularity?]]></title>
            <link>https://medium.com/@yoshithkesari/are-we-really-in-the-singularity-ba2e415ae7b2?source=rss-c9373a907960------2</link>
            <guid isPermaLink="false">https://medium.com/p/ba2e415ae7b2</guid>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[future]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Yoshith Kesari]]></dc:creator>
            <pubDate>Wed, 09 Sep 2026 18:36:43 GMT</pubDate>
            <atom:updated>2026-09-09T18:36:43.650Z</atom:updated>
            <content:encoded><![CDATA[<h3>Sam Altman and Elon Musk both just said the word out loud. Here’s what it actually means — and whether the claim holds up.</h3><p>A few weeks ago, Sam Altman went on a podcast and said something that would have sounded like science fiction five years ago:</p><blockquote><em>“We are now, like, in the singularity.”</em></blockquote><p>Elon Musk didn’t disagree. He’s said much the same — that AI is already superhuman at a growing list of tasks, and that we’re living inside the moment people used to only theorize about.</p><p>Okay. But what is the singularity, actually? And is either of them right?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gBFjnWSE4NhG_Ls8m_yOUQ.png" /></figure><h3>Where the idea comes from</h3><p>The concept isn’t new marketing language — it goes back to 1965, to a mathematician named <strong>I.J. Good</strong>. Good described a hypothetical machine that could out-think humans at intellectual work, including the work of designing better machines.</p><p>Once that happens, the loop is obvious:</p><p><strong>Humans build an AI. That AI helps build a better AI. The better AI helps build an even better one. And the loop keeps going.</strong></p><p>This is the core of what’s called <strong>recursive self-improvement</strong>, and the fear attached to it is called an <strong>intelligence explosion</strong> — the idea that once AI starts improving the technology behind AI, progress could accelerate past the point where humans can predict it, steer it, or even keep up with it.</p><p>For sixty years, that was a thought experiment. Now people running the largest AI labs in the world are saying it out loud, in the present tense.</p><h3>Why this is suddenly a live conversation</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/894/1*f82pq9JFSU7O_xR_9DAr-A.png" /></figure><p>Because we’re starting to see pieces of Good’s scenario show up in actual production numbers, not just speculation.</p><p>Anthropic disclosed that, as of May 2026, more than 80% of the code merged into its own production codebase was written by Claude — not by human engineers typing it line by line. Before Claude Code existed, that number was in the low single digits. In the same period, Anthropic’s engineers were merging roughly eight times as much code per day as they were back in 2024.</p><p>Read that carefully, because the interesting part isn’t “AI writes code now” — everyone already knew that. The interesting part is <em>what</em> that code increasingly builds: more AI.</p><p>Software is how AI systems get built, trained, evaluated, and shipped. So when AI starts writing a majority of that software, you’ve got a version of Good’s loop running for real, inside at least one company, right now. Not hypothetically. In a git log.</p><h3>But here’s the catch</h3><p>We are <strong>not</strong> at full, autonomous recursive self-improvement. Not close, according to the people closest to it.</p><p>Humans are still the ones deciding what problems are worth solving, what gets built, and whether the output is actually correct or good. Anthropic has said plainly:</p><blockquote><em>“We are not there yet, and recursive self-improvement is not inevitable.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/867/1*B0LQ3841gTeCEiXZlwKjzQ.png" /></figure><p>So the honest version of where things stand today looks less like:</p><p><strong>AI → better AI → even better AI → humans can’t keep up</strong></p><p>and more like:</p><p><strong>Humans + AI → better AI</strong></p><p>Still very much a human-in-the-loop process. The AI is doing more of the <em>execution</em>. Humans are still doing the <em>deciding</em>.</p><h3>The part worth actually paying attention to</h3><p>Here’s why that distinction matters, and why it might matter less over time.</p><p>If AI keeps absorbing more of the work that goes into building the next generation of AI — not just writing code, but eventually more of the judgment calls about what to build and how to evaluate it — the “humans + AI” loop starts looking a lot more like the “AI improving AI” loop Good described. The gap between those two scenarios isn’t fixed. It’s a gradient, and multiple people at the top of this industry are telling you, right now, which direction they think it’s sliding.</p><p>Whether that’s cause for excitement, concern, or both probably depends on how much of “deciding what to build” ends up staying human — and for how long.</p><h3>So… are we really in the singularity?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/858/1*RL6Tv3iFcoPM6q7YyBhSmA.png" /></figure><p>Maybe we’re already in it. Maybe we’re only seeing the opening scene of something much larger. Or maybe “singularity” is doing more rhetorical work than the actual data supports, and the honest answer is: <em>we’re on a steep curve, and no one — including the people naming it — fully knows where it goes next.</em></p><p>Either way, it’s no longer a lunchtime thought experiment. It’s a live question about what’s happening inside the companies building this technology right now — and it’s worth forming your own answer instead of borrowing someone else’s headline.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ba2e415ae7b2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Is AI Really Replacing Jobs? Anthropic Looked at Millions of Real Conversations.]]></title>
            <link>https://medium.com/@yoshithkesari/is-ai-really-replacing-jobs-anthropic-looked-at-millions-of-real-conversations-d4a3d46bbb0d?source=rss-c9373a907960------2</link>
            <guid isPermaLink="false">https://medium.com/p/d4a3d46bbb0d</guid>
            <category><![CDATA[research]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[jobs]]></category>
            <dc:creator><![CDATA[Yoshith Kesari]]></dc:creator>
            <pubDate>Tue, 28 Jul 2026 21:16:33 GMT</pubDate>
            <atom:updated>2026-07-28T21:16:33.848Z</atom:updated>
            <content:encoded><![CDATA[<p>Every week there’s a new headline warning that AI is about to wipe out millions of jobs. Every week, someone shares a “these jobs will disappear” list. And yet — <strong>most of us still have our jobs.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Bu1etBYLEkND54dZ006C_g.png" /></figure><p><strong>So what’s actually true?</strong></p><p>In March 2026, <strong>Anthropic </strong>(the company behind the AI model Claude) published a research report that tries to answer this properly — not with guesses, but by looking at real data on how people are actually using AI at work. It’s called <em>“</em><strong><em>Labor market impacts of AI: A new measure and early evidence</em></strong><em>,”</em> written by researchers <strong>Maxim Massenkoff </strong>and<strong> Peter McCrory.</strong></p><p>Here’s the whole thing, broken down in plain terms — no economics degree required.</p><h3>First: why should you trust this over the last hundred scary headlines?</h3><p>Before getting into their findings, the researchers admit something refreshing: <strong>predicting how new technology affects jobs has a bad track record.</strong></p><p>A few examples they point to:</p><ul><li>Back in the 2000s, economists predicted that a quarter of US jobs could be shipped overseas to cheaper labor markets. Ten years later, most of those jobs were still doing fine.</li><li>Government job-growth predictions have barely done better than simply guessing “next year will look like last year.”</li><li>Even years after robots became common in factories, experts still can’t agree on exactly how many jobs they actually replaced.</li></ul><p>The lesson: it’s really hard to know, in the moment, whether a new technology is quietly reshaping the job market or not. Usually we only understand it clearly by looking backward, years later — which isn’t very useful if you’re trying to protect people <em>now</em>.</p><p>So instead of making another prediction, this team built a measuring tool and started using it immediately — like installing a smoke detector before you know if there’s ever going to be a fire.</p><h3>The big idea: “AI could do it” vs. “AI is actually doing it”</h3><p>Here’s the central idea of the whole paper, explained as simply as possible.</p><p>Most studies about AI and jobs work like this: they look at everything a job requires, then ask “could an AI theoretically do this task, if it had every tool it needed?” If yes, that job gets labeled “at risk.”</p><p>But here’s the catch — <em>could</em> is not the same as <em>is</em>. Plenty of things AI is technically capable of, nobody’s actually using it for yet. Maybe it’s not reliable enough. Maybe there’s a law in the way. Maybe a person still needs to check the work before it goes anywhere.</p><p>So the researchers compared two different things:</p><ol><li><strong>What AI could theoretically do</strong> — based on an existing academic study that tested whether AI could complete each task at least twice as fast as a human, under lab conditions.</li><li><strong>What AI is actually being used for</strong> — based on real, anonymized data from millions of conversations people are having with Claude at work.</li></ol><p>And here’s the headline finding from this comparison: <strong>the gap between “could” and “actually is” is enormous.</strong> Take coding and IT-related jobs — an area where AI is capable of doing a huge share of the work in theory. In practice, real usage only covers about a third of those tasks so far.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TPytVzRklKncEeMcWgHLxA.png" /><figcaption>Figure 1. AI’s theoretical capability is substantially greater than its current observed workplace usage across knowledge-intensive occupations. This gap is the central measurement introduced in Anthropic’s study.</figcaption></figure><p>In other words: <strong>AI’s potential is way out ahead of how much it’s actually being used.</strong> That gap — and how quickly it shrinks over the next few years — is really the whole story this paper is trying to track over time.</p><h3>So which jobs are most affected right now?</h3><p>Using their more realistic “real usage” measure, the researchers ranked hundreds of occupations by how much AI is actually being used in them today. The most affected right now:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6FEfVvPaBo_g29uV1d248Q.png" /><figcaption>Figure 2. Real-world AI adoption is concentrated in occupations centered on reading, writing, coding, analysis, and structured information processing.</figcaption></figure><ol><li><strong>Computer programmers</strong> — the single most AI-touched job today</li><li><strong>Customer service representatives</strong> — increasingly being handled directly by AI systems, not just assisted by them</li><li><strong>Data entry workers</strong> — reading documents and typing information into systems, which AI handles well</li><li><strong>Medical records specialists</strong></li><li><strong>Market research analysts</strong></li><li><strong>Sales representatives</strong> (specifically in wholesale/manufacturing)</li><li><strong>Financial and investment analysts</strong></li><li><strong>Software quality testers</strong></li><li><strong>Information security analysts</strong></li><li><strong>Computer support specialists</strong></li></ol><p>Notice the pattern? These are almost all desk jobs built around reading, writing, analyzing, and typing — the exact kind of work a chatbot is good at.</p><p>On the flip side, roughly <strong>3 out of 10 workers</strong> are in jobs that barely show up in AI usage data at all — cooks, bartenders, lifeguards, mechanics, dishwashers. Anything hands-on, physical, or requiring you to be in a specific place with specific tools is still almost completely untouched.</p><h3>The Biggest Surprise: AI Is Affecting High-Skill Work First</h3><p>If you assumed the workers most affected by AI would be in lower-paid, “easier to replace” jobs, the data says the opposite.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tJhhL3OXIgw_r32eQ5AgNQ.png" /><figcaption>Figure 3. Contrary to common assumptions, the occupations with the highest observed AI exposure are generally higher-paying, more educated, and employ a larger share of women.</figcaption></figure><p>Compared to workers in jobs AI barely touches, workers in the most AI-affected jobs are, on average:</p><ul><li><strong>More likely to be women</strong></li><li><strong>About 4 times more likely to have a graduate degree</strong></li><li><strong>Earning about 47% more per hour</strong></li></ul><p>This flips a very common assumption people carry around. Right now, AI is having its biggest real-world impact on <strong>educated, well-paid, white-collar workers</strong> — not low-wage or “unskilled” jobs, like a lot of public conversation assumes.</p><h3>Does this match what economists already expected?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f4WyXOAdT6kdPi9FzzPcNg.png" /><figcaption>Figure 4. Occupations with greater AI exposure tend to have slightly weaker long-term employment growth projections, although the relationship is modest rather than deterministic.</figcaption></figure><p>The researchers checked their measure against something independent: <strong>official US government job-growth forecasts</strong>, which predict how much every occupation will grow or shrink between 2024 and 2034.</p><p>They found a real — but mild — connection: jobs with more AI usage today tend to have slightly weaker growth forecasts for the next decade. Specifically, for every extra 10% of a job that AI is being used for, that job’s projected 10-year growth rate drops by about half a percentage point.</p><p>That’s a real signal, but it’s a soft one, not a dramatic one. For example, software development is one of the more AI-exposed jobs on the list, yet it’s still projected to grow strongly — AI usage is clearly not the only thing determining a job’s future.</p><h3>Now the question everyone actually cares about: is AI costing people their jobs?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q_HdGgGzXuHeYvsFxFAcWg.png" /><figcaption>Figure 5. The study finds no detectable increase in unemployment among AI-exposed workers so far, although hiring into AI-intensive occupations has softened for younger workers.</figcaption></figure><p>Here’s the honest, no-spin answer: <strong>based on the data so far, no — not in any way we can clearly detect yet.</strong></p><p>The researchers compared unemployment rates for the most AI-affected workers versus the least-affected workers, tracking all the way back to 2016 (years before ChatGPT even existed) up through today. Since AI chatbots went mainstream in late 2022, there has been <strong>no meaningful increase in unemployment</strong> for the more-affected group compared to the less-affected group. Both groups have moved up and down together, in step, the whole time.</p><p>To be precise about it: the measured difference between the two groups since AI chatbots took off is so small — and so uncertain — that the researchers can’t even say confidently that it’s a real effect, rather than just normal statistical noise.</p><p>Translation: <strong>if AI is quietly pushing people out of jobs, it isn’t happening at a scale big enough to show up in the numbers yet.</strong></p><h3>The one exception worth paying attention to</h3><p>There is one softer, more interesting signal buried in the data — and it’s specifically about <strong>young workers, ages 22 to 25.</strong></p><p>This isn’t about people losing jobs they already have. It’s about <strong>entry-level hiring</strong>. The researchers found that, compared with the period before ChatGPT became mainstream, <strong>workers aged 22–25 were about 14% less likely to start a new job in occupations with high AI exposure.</strong> In other words, the earliest measurable effect isn’t widespread layoffs — it’s that <strong>fresh graduates and early-career workers appear to be finding it harder to enter AI-intensive professions.</strong></p><p>That’s a real, measurable pattern — and it lines up with similar findings from another team of economists. But even the researchers who found it are cautious about how much weight to put on it. It’s only just barely strong enough, statistically, to trust. And there are other explanations that have nothing to do with AI — maybe these young workers are staying in school longer, or taking jobs in different fields instead, since it’s hard to track exactly where people go once they don’t show up in a certain job category.</p><p>So think of this less as “proof that AI is hurting young people’s careers” and more as “the one loose thread worth watching closely going forward.”</p><h3>Putting it all together — what does this actually mean?</h3><p>Here’s the simplest possible summary of the whole paper:</p><ul><li><strong>AI’s technical capability is way ahead of how much it’s actually being used.</strong> Most of the potential disruption hasn’t happened yet — it’s just sitting there, waiting to be deployed.</li><li><strong>The jobs most touched by AI today are educated, well-paid, white-collar roles</strong> — coding, customer service, financial analysis, research — not low-wage, “unskilled” work like most people assume.</li><li><strong>There’s no clear evidence yet that AI is putting people out of work.</strong> Unemployment for AI-exposed workers looks basically the same as everyone else’s.</li><li><strong>The clearest early warning sign is in entry-level hiring. Workers aged 22–25 are about 14% less likely to start new jobs in AI-intensive occupations than before ChatGPT became mainstream, suggesting fresh graduates may face a tougher path into these roles.</strong></li></ul><p>The researchers are careful to frame all of this as a starting point, not a final verdict. Their real goal is to keep repeating this same measurement every few months, so that if things do start to shift, someone will be watching closely enough to catch it early — instead of only realizing what happened years later, the way we did with globalization and factory automation.</p><p><strong>Bottom line:</strong> Today’s AI is changing how people work far more than whether they work. The evidence doesn’t show widespread job displacement yet — but it does show where the first cracks may be forming. By measuring real-world AI usage instead of hypothetical capability, this research provides an early-warning system for understanding how the labor market evolves over the coming years.</p><p><em>Source: Massenkoff, M. &amp; McCrory, P. (2026). “Labor market impacts of AI: A new measure and early evidence.” Anthropic.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d4a3d46bbb0d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Semester I Finally Stopped Fearing Exams]]></title>
            <link>https://medium.com/@yoshithkesari/the-semester-i-finally-stopped-fearing-exams-657281e821bc?source=rss-c9373a907960------2</link>
            <guid isPermaLink="false">https://medium.com/p/657281e821bc</guid>
            <category><![CDATA[google]]></category>
            <category><![CDATA[college]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[notebooklm]]></category>
            <dc:creator><![CDATA[Yoshith Kesari]]></dc:creator>
            <pubDate>Tue, 21 Jul 2026 20:54:36 GMT</pubDate>
            <atom:updated>2026-07-21T20:54:36.428Z</atom:updated>
            <content:encoded><![CDATA[<h3>A story about the semester I stopped memorizing and finally started understanding.</h3><p>It’s 11 PM, the night before an exam, and I’m looking at a 120-page PDF like it personally owes me money.</p><p>I open my notes. I close them five minutes later.</p><p>If you’ve ever had a night like that, you already know the question sitting underneath all the panic.</p><p><strong>How do people actually finish all this?</strong></p><h3>Semester one: hope as a study strategy</h3><p>First-semester me didn’t have a study strategy. I had hope.</p><p>I read everything, highlighted everything according to a color code I invented on a Tuesday and abandoned by Thursday, and reread chapters the night before, mistaking <em>“this looks familiar”</em> for <em>“I know this</em><strong><em>.</em></strong><em>”</em></p><p>Every exam felt the same. Walk in, hope the questions matched the few topics I half-remembered, sit down, hope for the best. I didn’t fail — but I never walked out of a hall feeling like I actually understood what I’d written. It always felt like I’d gotten away with something.</p><h3>The mistake I didn’t know I was making</h3><p>For the longest time, I believed studying meant reading. More hours meant better preparation. Reading something twice meant I’d learned it.</p><p>Then one evening, about an hour into “studying,” I was interrupted by a simple question: <em>“Wait… why does that actually happen?”</em></p><p>I opened my mouth. Nothing came out. I looked back at the paragraph I’d apparently just read twice — I recognized the words, but I didn’t understand the idea.</p><p>That moment stayed with me far longer than any exam ever did. For the first time, I realized there was a huge difference between recognizing information and actually understanding it.</p><h3>The accident</h3><p>A few nights later, mostly because I didn’t feel like opening my notes again, I uploaded one of my PDFs into NotebookLM just to see what would happen. I wasn’t trying to fix my study routine — I was avoiding it for another ten minutes.</p><p>Instead of reading another chapter, I started asking questions. Not definitions. Questions like <em>“Why does this actually happen?”</em></p><p>One question became another. Every answer made me curious enough to ask one more, and slowly the topic stopped feeling like something I needed to memorize and started feeling like something I genuinely understood. For the first time, studying felt less like reading a textbook and more like having a conversation.</p><p>Then one thought hit me: <strong>I hadn’t been studying the subject. I’d been studying the PDF.</strong></p><h3>The real change</h3><p>The first thing that changed wasn’t my marks. It was my confidence.</p><p>I could explain concepts without looking at my notes. When I didn’t understand something, I noticed it immediately instead of pretending I did. Revision got shorter, not because I was rushing, but because I wasn’t relearning everything — I was simply reminding myself of things I already understood.</p><p>Then came the night before my next exam, and for the first time in a long time, I was calm. Not because I knew every answer. Because I finally trusted the way I’d learned.</p><h3>The exam hall, take two</h3><p>The exam hall hadn’t changed. The papers still rustled. The invigilator still said, <em>“You may begin.”</em></p><p>But something inside me had.</p><p>I looked at the first question and thought, <em>“I’ve actually understood this before.”</em> Not memorized — understood. The questions no longer felt like strangers. They felt familiar, because I’d already wrestled with the ideas behind them.</p><h3>The lesson that stayed with me</h3><p>This story isn’t really about NotebookLM. It’s about realizing that reading and understanding are two completely different things. For three semesters, I genuinely believed they were the same. They weren’t.</p><p>Reading was never my problem. Understanding was. The exam never exposed what I hadn’t read — it exposed what I hadn’t understood.</p><p>I still get nervous before exams, and I don’t think that feeling ever completely goes away. The difference is that now I know what to do with it. Instead of rereading the same chapter and hoping the third time finally sticks, I ask a better question.</p><p>And somehow, that’s when the studying actually starts.</p><h3>A small note before I move on</h3><p>If you’ve been reading my stories so far, thank you. Writing them has helped me understand not just technology, but how I learn, think, and explain ideas.</p><p>This will probably be the last article built entirely around one of my own experiences. What comes next will be different — I’ll be diving into research papers, AI systems, engineering concepts, and the ideas shaping modern technology, not to summarize them, but to understand them deeply and explain them in a way that’s easier to follow.</p><p><strong>The stories may be ending.</strong></p><p><strong>The curiosity isn’t.</strong></p><p>See you in the first breakdown.</p><p>— <strong>Yoshith Kesari</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=657281e821bc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Accidentally Said “Kernel.” Then I Had to Learn What It Meant.]]></title>
            <link>https://medium.com/@yoshithkesari/i-accidentally-said-kernel-then-i-had-to-learn-what-it-meant-d82c98f4dacd?source=rss-c9373a907960------2</link>
            <guid isPermaLink="false">https://medium.com/p/d82c98f4dacd</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[anaconda-python]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[student-life]]></category>
            <category><![CDATA[jupyter-notebook]]></category>
            <dc:creator><![CDATA[Yoshith Kesari]]></dc:creator>
            <pubDate>Tue, 14 Jul 2026 20:33:47 GMT</pubDate>
            <atom:updated>2026-07-14T20:33:47.776Z</atom:updated>
            <content:encoded><![CDATA[<h3>One question about Jupyter Notebook exposed the difference between using a tool and understanding why it exists.</h3><p>Every engineering student has at least one moment they wish they could replay. This was mine.</p><p>It was a normal lab session. Nothing about that day suggested it would end with me quietly Googling operating system architecture at midnight, questioning every technical opinion I’d ever confidently held.</p><p>I had my own laptop out, running my own setup, doing the thing I always do — one cell at a time, check the output, tweak, run again. Most of the room was on the lab machines. I just preferred working the way I already knew.</p><p>A faculty member walked past, glanced at my screen, and stopped.</p><p>“Why Jupyter Notebook?”</p><p>I wasn’t expecting the question. Mostly because I’d never asked myself that question before.</p><p>Not hostile. Genuinely curious, the way a good teacher asks something they already know the answer to, mostly to see what you’ll do with it.</p><p>I had about a second to respond before the pause became a thing.</p><p>“Kernel,” I said.</p><p>Confident. Final. The tone of someone closing a case.</p><p>It sounded intelligent. Which, unfortunately, isn’t the same thing as being correct.</p><p>He didn’t nod and move on, which is what I’d been counting on.</p><p>“What is a kernel?”</p><p>And there it was. The follow-up I hadn’t prepared for, because I’d assumed — incorrectly, as it turns out — that one confident buzzword would be sufficient currency for the entire conversation.</p><p>My brain did the thing brains do under pressure: it panicked, rifled through every vaguely-related fact it owned, and grabbed the nearest one wearing a name tag that looked official.</p><p>“It’s like hardware,” I said.</p><p>Even while saying it, part of my brain quietly whispered, <em>“…that doesn’t sound right.”</em></p><p>I said it anyway.</p><p>Wrong. Not partially wrong. Not “technically if you squint” wrong. Just wrong, delivered with the same confidence as the correct answer would’ve had, which is somehow worse.</p><p>He smiled. Laughed, a little. Didn’t correct me. Didn’t explain. He just looked at me for a second the way you look at someone who’s clearly capable of finding the answer themselves, and then he walked off to check someone else’s work.</p><p>That was it. No lecture. No embarrassment ritual. Just a question, a wrong answer, and a laugh that took maybe two seconds and somehow outlasted the entire semester.</p><h3>The laugh wasn’t the problem. The laugh was accurate.</h3><p>I want to be clear about something, because it would be easy to tell this story as “professor humiliates student,” and that’s not what happened, and it’s not what this is.</p><p>He wasn’t laughing at me being wrong. Being wrong isn’t funny, and he knew that better than I did. I think he was laughing at the specific shape of my wrongness — the fact that I’d answered a hardware-adjacent-sounding question with a genuinely confident non-answer, twice in a row, without once pausing to check if I actually knew what I was saying.</p><p>He didn’t owe me an explanation. He’d already given me something more useful than an explanation: a question I couldn’t stop turning over.</p><p>The assignment got finished that day. Submitted, graded, forgotten within a week. The question didn’t get finished. It just sat there, quietly, refusing to leave.</p><h3>The first thing I found made everything worse</h3><p>That night, mostly out of wounded pride, I searched “what is Jupyter Notebook actually.”</p><p>First real discovery: the name isn’t random. Jupyter comes from <strong>Julia, Python, and R</strong> — the three languages the project originally set out to support.</p><p>For about thirty seconds I felt incredibly smart.</p><p>Then I realized I still couldn’t answer the original question.</p><p>I’d just traded one piece of trivia for another. Same confident hollowness, new packaging. I sat with that for a minute, mildly annoyed at myself, and then realized the actual problem. I’d been asking the wrong question the entire time.</p><p>I kept asking, “What is Jupyter Notebook?”</p><p>I should have been asking, “Why does Jupyter Notebook exist?”</p><p>That turned out to be a much more interesting question than “What is Jupyter?” — and it’s the actual turning point of this whole story. Everything before it was trivia. Everything after it was understanding.</p><p>By the end of that night I had twelve browser tabs open. Documentation. Blog posts. A Stack Overflow thread from 2015. A YouTube video I never finished. One answer kept leading to another question, which led to another tab, which led to a question I hadn’t even known to ask an hour earlier.</p><p>Somehow, I understood less than when I started.</p><p>Which, oddly enough, felt like progress.</p><h3>Why the thing exists in the first place</h3><p>Here’s what nobody had bothered explaining to me in any of the tutorials I’d half-read before that night: Jupyter wasn’t built to replace a code editor. It was built to solve a completely different problem — the problem of thinking out loud while you work, instead of committing to a full plan before you’ve learned anything.</p><p>A normal script assumes you already roughly know what needs to happen. Write it top to bottom, run it, check the result. Fine, if you actually know what you’re doing, which is a category I rarely belong to on day one of anything.</p><p>A lot of real work doesn’t start with knowing. You’re exploring a dataset. Testing a hunch. Poking at something to see how it reacts. You want to run one small piece, look at what happened, and decide your next move based on the evidence in front of you — not write the entire investigation up front and hope the ending holds together.</p><p>That’s the actual pitch. Not “code goes here instead of there.” Thinking in public, one guess at a time, with the evidence sitting right next to your reasoning instead of buried three layers down in a terminal log, pretending to help.</p><p>I picked up a small Movie Recommendation System not long after that lab session, half as a project, half as an excuse to find out whether I’d accidentally been right about something I clearly didn’t understand.</p><h3>Where cells stopped being boxes and started being obvious</h3><p>Every evening I’d open the notebook convinced I knew exactly what I wanted to build. Twenty minutes later I’d be asking a completely different question than the one I’d sat down with.</p><p>The first thing that actually clicked, working on that project, was how different a notebook felt from writing a script. Not better, necessarily. Different, in a way I hadn’t noticed until I had a real reason to notice it.</p><p>A cell is a small block of code you can run entirely on its own, without dragging the rest of the file along with it. Doesn’t sound remarkable in the abstract. It becomes remarkable the moment you’re staring down a dataset that takes a genuinely long time to load, and you’re trying to tweak one small function fifteen times in a row.</p><p>In a normal script, tweaking that function means reloading the entire dataset every single time — re-cooking the whole meal because you want to check whether the sauce needs more salt. In the notebook, I loaded the data once. It stayed. I moved to the cell where I was adjusting how movies got compared to each other, changed a line, ran just that cell, and got an answer in under a second.</p><p>Change. Run. Look. Adjust. That loop, repeated fifty or sixty times over one evening, is the entire reason anyone reaches for a notebook in the first place. Not the syntax highlighting. Not the aesthetic. The speed between having a hunch and finding out your hunch was garbage — which, statistically, most hunches are, and the faster you find that out, the faster you get to the next one.</p><p>That’s also, incidentally, when the kernel stopped being a buzzword and started being a fact I actually needed.</p><h3>The moment “hardware” turned into something real</h3><p>Here’s what I’d gotten backwards that day in the lab: a kernel isn’t hardware. It’s not even close to hardware. It’s a running process, sitting quietly behind the notebook interface, holding onto every variable, every function, every dataset you’ve loaded, for as long as it stays alive.</p><p>That’s why I could load my movie dataset in one cell, close it, scroll to a completely different part of the notebook, and still reference that same data ten cells later without reloading anything. The kernel remembers. It’s less like hardware and more like a whiteboard nobody ever wipes clean, sitting patiently in a room you keep walking in and out of over the course of an evening.</p><p>This also explained a specific flavor of chaos I’d been quietly blaming on bad luck for weeks — why restarting the kernel would sometimes fix a bug with no visible cause. If I’d been running cells out of order, tweaking one, wandering back, editing an earlier cell, running a later one before the earlier change had actually taken effect, the kernel’s memory could end up holding a version of my code that no longer matched what was written on the page in front of me. Restarting the kernel just wipes the whiteboard and starts fresh. Once that landed, half my “impossible” bugs stopped being impossible. They were just old memories the kernel was rude enough to keep around, uninvited.</p><p>I sat back from my laptop that night and thought, with real clarity for the first time: this is what he was actually asking about. Not a trivia definition. The thing that made the whole workflow behave the way it did. And I’d answered “hardware,” out loud, to his face, like I knew.</p><h3>Execution order, or how to debug a problem that was never real</h3><p>There’s a trap almost everyone falls into once they’ve been running notebooks for a while, and I found it exactly on schedule.</p><p>Notebooks let you run cells in any order you like. Genuinely useful. Also the precise mechanism by which you’ll spend forty minutes debugging a bug that doesn’t exist — cell twelve ran before cell nine got updated, and now cell twelve is confidently using a version of something that no longer matches reality anywhere except inside the kernel’s memory.</p><p>I blamed Python. Then Pandas. Then, briefly and unfairly, NumPy.</p><p>Turns out it was me.</p><p>The notebook doesn’t care what order the cells appear on the page. It only cares what order you actually ran them in. Those two things drift apart faster than seems reasonable, especially three “just one more quick test” cells deep into a session that started as a fifteen-minute check and is now somehow two hours old.</p><p>Once I understood the kernel as memory that outlives the page, rather than a fresh read every time, this stopped being mysterious and became a checklist instead. Restart. Run everything top to bottom. See if the bug survives. Usually it doesn’t. Usually it was never actually there.</p><h3>The habit I ignored until it cost me an evening</h3><p>Jupyter lets you drop plain-text notes right between your code cells — Markdown-formatted, sitting next to the code they’re explaining.</p><p>I’d ignored this feature for weeks. Felt optional. Decorative, even, like something you’d add for someone else’s benefit, not your own.</p><p>Then I came back to the recommendation system three weeks after shelving it for exams, opened the notebook, and had no memory whatsoever of why I’d chosen cosine similarity over anything else, or what a strange intermediate dataframe sitting in an earlier cell was even doing there. Past-me had left no notes. Past-me had apparently assumed present-me would just remember, which is the single most optimistic thing past-me has ever done on my behalf.</p><p>Two sentences of Markdown, at the time, would have saved me an entire evening of reverse-engineering my own decisions like a detective investigating a case I’d personally closed. That’s the actual value of it. Not making the notebook look presentable for a stranger. Leaving a trail for the one person guaranteed to need it later — you, having forgotten everything, including, apparently, the difference between a kernel and a graphics card.</p><h3>Colab is genuinely great. This project just didn’t want it.</h3><p>A friend, watching me work through the recommendation system one evening, asked why I wasn’t just using Google Colab — free GPU, nothing to install, shareable with a single link, works from any browser on any machine.</p><p>All true. For a lot of projects, Colab is the obviously smarter call, especially anything hungry for GPU power my own laptop simply does not have.</p><p>This project, though, had a dataset I wanted to keep sitting on my own machine, a couple of package versions I didn’t feel like fighting Colab’s environment over every session, and a rhythm where I was in and out of the notebook constantly through the day — without waiting on uploads, without gambling on a runtime quietly disconnecting mid-thought and wiping the kernel’s memory like none of it had happened. Running locally meant my kernel stayed alive exactly as long as I needed it to, my files stayed exactly where I’d left them, and none of it depended on someone else’s server having room for me that particular afternoon.</p><p>Colab wasn’t the wrong tool. It just wasn’t solving the problem I had.</p><p>Colab wins outright on shareability and free compute. Local won, for this specific project, because I wanted control over my own environment more than I wanted someone else’s GPU doing me a favor. My friend kept using Colab the whole semester. We were both right, for completely different reasons — which happens in this field far more often than people with strong opinions on the internet tend to admit.</p><h3>VS Code was never the enemy here</h3><p>None of this makes a notebook the superior life form. That’s not true, and pretending otherwise would turn this into a much less honest article.</p><p>A notebook is a laboratory. VS Code and PyCharm are a factory floor. In the lab, you’re testing a hypothesis, poking at something to see if it reacts, perfectly happy to run things in a slightly chaotic order because you’re still figuring out what you’re even building. On the factory floor, you’re constructing something meant to last — structured, testable, organized so that someone else, or future-you, can walk in six months later and understand how the machine fits together without wanting to take it apart out of spite.</p><p>Comparing VS Code and Jupyter is a little like comparing a microscope to a workshop. They answer completely different questions.</p><p>Try building an actual backend service inside a notebook sometime, if you’d like to personally discover why “run any cell in any order, forever” is a genuinely alarming property for something meant to behave reliably in production. It falls apart fast, and it deserves to.</p><p>I use VS Code constantly. Just not for the same job. The notebook is where I find out if an idea has a pulse. VS Code is where I build the version of that idea sturdy enough to survive contact with people who are far less forgiving than a professor quietly waiting to see what I’d say next.</p><h3>The second conversation</h3><p>Months later, same lab, same faculty member, a different project entirely. He asked a genuinely harder question this time — something about how I was managing state across a slightly messy analysis I was clearly still improvising in real time.</p><p>I noticed the difference before he did.</p><p>There was no scramble. No mental filing cabinet flying open, searching for the nearest official-sounding word. I just answered — the kernel holds onto everything you’ve run so far, restarting it clears that memory, execution order matters more than the order cells happen to sit on the page. Plain sentences. No performance in them.</p><p>It wasn’t confidence for the sake of sounding confident this time. It was closer to just… not needing to perform, because I actually knew what I was describing. I could feel the difference from the inside, which was strange, because the last time I’d stood in roughly this spot, answering a question from roughly this person, I hadn’t been able to feel anything except the specific dread of being asked a follow-up.</p><p>He listened, nodded — the real nod this time, not the one I’d tricked out of him months earlier — and moved on to the next student without making a thing of it.</p><p>He never mentioned the “hardware” answer. I don’t think he needed to. I think he already knew that laugh would do more work over time than any correction he could have given me on the spot.</p><h3>What I actually got wrong that day</h3><p>I’ve thought about this more than the moment probably deserves, which feels appropriate, since that’s kind of the whole point of this article.</p><p>I wasn’t wrong because I said “kernel.” That part was, technically, the right word. I was wrong because I didn’t know why it mattered — and saying the right word for the wrong reason is a strange, uncomfortable place to stand, because it feels like knowledge right up until someone asks one more question.</p><p>I answered “kernel” before I understood the kernel.</p><p>Looking back, I think that was the day I stopped collecting technical words and started asking why they existed in the first place.</p><p>Sometimes the best engineering lesson isn’t learning the right answer. It’s discovering why your first answer wasn’t enough.</p><p>One article isn’t enough to master Jupyter Notebook.</p><p>It wasn’t enough for me either. This was simply the question that started the journey. Not the whole journey. Just the part where I stopped confidently guessing and started actually finding out.</p><p>I’ll bring another story next Wednesday.</p><p>Until then, keep asking “why”.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d82c98f4dacd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Folder Named final_final_v7 Finally Taught Me Git.]]></title>
            <link>https://medium.com/@yoshithkesari/the-folder-named-final-final-v7-finally-taught-me-git-363615251d99?source=rss-c9373a907960------2</link>
            <guid isPermaLink="false">https://medium.com/p/363615251d99</guid>
            <category><![CDATA[version-control]]></category>
            <category><![CDATA[blogging]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[github]]></category>
            <dc:creator><![CDATA[Yoshith Kesari]]></dc:creator>
            <pubDate>Tue, 07 Jul 2026 21:57:09 GMT</pubDate>
            <atom:updated>2026-07-07T21:57:09.244Z</atom:updated>
            <content:encoded><![CDATA[<p>Last time, I told you I’m 19, I’m a third-year B.Tech student, and I build things that mostly work. I promised the next post would be more technical.</p><p>This is that post.</p><p>And it starts with a confession: for almost two years, my version control system was a folder naming convention. A bad one. An actively insulting one, if I’m honest about it now.</p><h3>The folder that started this whole thing</h3><p>Somewhere on my old laptop, buried three drives deep, there’s a folder called final_final_v7.</p><p>Not a joke. Not exaggerated for the article. A real folder, from a real project, that I genuinely believed was a functioning system for tracking my own work.</p><p>Here’s how it happened. I’d build something. Then my professor, or a teammate, or my own future self would want a change. So I’d copy the whole project folder, paste it next to the original, and rename it something like Project New. Then another change would come in, and I&#39;d copy that one too. Project Final. Then Project Final Latest. Then, and I genuinely don&#39;t remember what emergency prompted this one, Project Final Latest Real.</p><p>Eventually I had six versions of the same project sitting in the same directory, and not one of them could tell me, with any confidence, which was newest, which had the bug fixed, or which one my teammate had actually tested.</p><p>I was doing manual version control. Badly. With my hands. Using folder names as a substitute for an actual system.</p><p>Everyone told me to “just use Git.” Nobody told me what that actually meant. So I nodded, installed it, ran two commands I copy-pasted from a tutorial, and went right back to copying folders, because at least I understood folders.</p><h3>Why does Git even exist?</h3><p>Most explanations start with:</p><p><em>“Git is a version control system.”</em></p><p>Which explains nothing. It’s the kind of sentence that sounds correct and teaches you absolutely nothing, the way “a car is a mode of transportation” doesn’t help you drive one.</p><p>Here’s the actual answer.</p><p>Software changes constantly. Every day, sometimes every hour. And every developer, on every project, eventually needs to do four things: save history, undo mistakes, collaborate with other people without overwriting their work, and experiment without wrecking whatever currently works.</p><p>Git does all four. That’s the whole pitch. Everything else is implementation detail.</p><p>I didn’t understand this for a long time because I’d never actually needed to collaborate with anyone. It was just me, my folders, and my questionable naming scheme. The moment I worked on a group project and someone else’s changes silently erased three hours of mine, Git stopped being an optional tool and started being something I actually needed to understand.</p><h3>Version control, without the textbook voice</h3><p>Here’s the simplest way I’ve found to explain it to myself.</p><p>Imagine Google Docs. Every edit is remembered. You can open the version history and restore exactly how the document looked yesterday, or an hour ago, or right before your friend “helpfully” deleted your intro paragraph.</p><p>Git does that. For code. That’s genuinely most of the concept.</p><p>The difference is that Git doesn’t track one document — it tracks an entire project, every file inside it, and it lets multiple people edit that project at the same time without stepping on each other.</p><h3>The hidden folder doing all the work</h3><p>The moment you run:</p><pre>git init</pre><p>Git creates a folder called .git inside your project. It&#39;s hidden, and it&#39;s easy to forget it exists, which is exactly why I ignored it for so long.</p><p>Everything Git knows about your project lives inside that one folder. Every commit, every branch, every log entry, your entire history — all of it, sitting quietly in a folder most people never open.</p><p>I once accidentally deleted a .git folder trying to &quot;clean up&quot; a project directory. I still think about that afternoon. Don&#39;t delete .git. Git without .git is just a regular folder with an inflated sense of self-importance.</p><h3>The staging area, explained through online shopping</h3><p>This is the concept that confused me longest, so I’m going to explain it the way someone finally explained it to me.</p><p>Think about buying something online. You don’t purchase things the instant you see them. You add them to a cart first. Then, separately, you check out.</p><p>Git’s staging area works the same way.</p><pre>git add .</pre><p>This doesn’t save your changes permanently. It just says: <em>these are the changes I’m considering including in my next save point.</em> You’re filling the cart. You haven’t checked out yet.</p><p>Checking out — the actual permanent save — is a separate step. Which brings us to commits.</p><h3>A commit is a save point, not a snapshot of every second</h3><pre>git commit</pre><p>This is the moment Git actually saves something. Not automatically, not every few seconds in the background — only when you decide the current state of your project is worth remembering.</p><p>Every commit carries a few things with it: an ID, an author, a date, a message you wrote, and a link back to whatever commit came before it. That last part matters more than it looks — it’s how Git builds an entire chain of history instead of just a pile of disconnected saves.</p><p>Each commit also gets a unique code, something like 3a8bd72, generated through a hashing process. You&#39;ll never memorize these, and you don&#39;t need to. Git uses them internally so it never has to guess which version is which. No more final_final_v7. Git just knows.</p><h3>HEAD is just a bookmark</h3><p>This one sounds more intimidating than it is.</p><p>Imagine reading a book and keeping a bookmark at your current page. HEAD is that bookmark, except for your project. It marks exactly where you currently are in your project’s history.</p><p>Once I stopped picturing HEAD as some abstract technical concept and started picturing an actual bookmark sitting in an actual book, the rest of Git’s vocabulary stopped feeling so intimidating.</p><h3>A branch is not a copied folder. It’s a pointer.</h3><p>This was the single biggest misunderstanding I carried for the longest time, because I kept mentally mapping “branch” onto “the thing I already do” — copying the whole project into a new folder.</p><p>A branch isn’t a copy. It’s a pointer to a specific commit. That’s genuinely the whole definition.</p><p>Picture your main project moving forward, commit after commit. At some point you create a branch called, say, feature-login. That branch starts at the exact same history as main — nothing is duplicated, nothing is copied. It simply lets you keep adding new commits down a separate path, while main stays exactly where it was.</p><p>Two paths. One shared history. No duplicated folders sitting around confusing everyone, including future-you.</p><p>When the feature is done, you merge it back:</p><pre>main: A → B → C<br>feature: D → E</pre><p>merges into:</p><pre>A → B → C → merge → F</pre><p>Sometimes, if the same line of code was changed differently on both branches, Git can’t decide which version is correct on its own. That’s a merge conflict. Git isn’t broken when this happens — it’s just asking you, politely, to make a decision it isn’t allowed to make for you.</p><h3>Push, pull, fetch — and the difference nobody explains clearly</h3><ul><li><strong>Push</strong> sends your local commits up to GitHub.</li><li><strong>Pull</strong> brings GitHub’s commits down to your machine.</li><li><strong>Fetch</strong> downloads what’s changed on GitHub, but doesn’t merge it into your work automatically.</li></ul><p>That third one confused me for a long time, mostly because most tutorials skip explaining it and just tell you to pull and move on. Turns out, pull is really just fetch followed by an automatic merge. Two steps, disguised as one command.</p><h3>Git and GitHub are not the same thing</h3><p>Git is software. It runs on your machine, and it works completely fine without the internet.</p><p>GitHub is a website that hosts Git repositories and adds collaboration tools on top — pull requests, issues, that sort of thing.</p><p>Git can exist without GitHub.</p><p>GitHub cannot exist without Git.</p><p>I confused these two for embarrassingly long. GitLab and Bitbucket exist too, doing roughly the same job as GitHub, in case you ever end up somewhere that isn’t GitHub and wonder why none of the buttons look familiar.</p><h3>The commands you’ll actually type, daily</h3><pre>git status</pre><p>Shows what’s modified, what’s staged, what’s untracked, and which branch you’re currently on. This is probably the single most-used Git command in existence, and for good reason — it’s the command that tells you where you actually stand before you do anything else.</p><pre>git log</pre><p>Your project’s history, laid out like a browser history, except for code instead of web pages you’re mildly embarrassed you visited.</p><p>Older tutorials will tell you to use git checkout for everything — switching branches, restoring files, moving between commits. Modern Git split that one overloaded command into two cleaner ones: git switch for branches, and git restore for files. Cleaner, less confusing, and worth learning the new way even if half the internet&#39;s tutorials still teach the old one.</p><h3>.gitignore exists to protect you from yourself</h3><p>Some files should never be tracked by Git at all: node_modules, .env, __pycache__, dist, build.</p><p>node_modules gets ignored because it&#39;s enormous and entirely regenerable — nobody needs its history, they just need to reinstall it.</p><p>.env gets ignored because it holds your actual secrets. Passwords. API keys. The stuff that, if it ends up in a public repository, becomes very quickly someone else&#39;s problem to solve, usually at your expense.</p><p>I learned this one the hard way, the way most people do — by pushing an API key to a public repo and getting a very fast, very unamused email about it. A .gitignore file takes ten seconds to set up and saves you from that entire experience.</p><h3>The everyday rhythm</h3><p>Most days, using Git looks like this:</p><p>Edit something. Check status. Stage the changes. Commit them with a message that actually describes what changed. Push it up.</p><p>Working with someone else adds one extra step to the rhythm: they commit and push their side, you pull their changes down, and you keep going from there. No copied folders. No guessing whose version is newest. Just a shared, ordered history that both of you can trust.</p><h3>Why Git is actually fast</h3><p>Here’s something that surprised me once I understood it: Git doesn’t store a full copy of every file in every commit. It stores snapshots, and any file that hasn’t changed since the last commit is simply referenced, not duplicated.</p><p>That’s a big part of why Git stays fast even on projects with years of history. It’s also, incidentally, why Git isn’t great with large binary files — images, videos, big zip archives — since those can’t be “referenced” the same efficient way plain text can.</p><h3>Write commit messages like someone else has to read them</h3><p>Because someone will. Possibly you, in four months, with zero memory of what you were thinking.</p><p>Good:</p><p>Fix login validation</p><p>Add payment API endpoint</p><p>Not good, and yet somehow the entire history of my early Git usage:</p><p>update</p><p>asdf</p><p>final</p><p>latest</p><p>I am not proud of this. I’m including it anyway, because pretending I always wrote good commit messages would undercut the entire point of this post.</p><h3>The mistakes almost everyone makes early on</h3><p>Running git add . without actually checking what&#39;s being staged.</p><p>Committing secrets because there was no .gitignore in place yet.</p><p>Making one enormous commit that touches fifteen unrelated things, instead of several small, clearly-labeled ones.</p><p>Writing commit messages that mean nothing to anyone, including future-you.</p><p>Pushing code that doesn’t actually run.</p><p>Avoiding branches entirely and just working directly on main, which works fine right up until it very much doesn&#39;t.</p><p>I’ve done every single one of these. Some of them more than once, which is its own kind of achievement.</p><h3>The analogy that finally made it click</h3><p>Git is a save point. Like the ones in a video game, the kind you create right before a boss fight you’re not fully confident about.</p><p>Without Git, every mistake feels permanent. You break something, and now you’re afraid to touch anything else, because you have no way back to the version that worked.</p><p>With Git, mistakes become experiments. You can branch off, try something risky, and if it goes badly, you just go back to where you were. Nothing lost. Nothing permanent. Just a save point you didn’t need this time, sitting there in case you do next time.</p><h3>What final_final_v7 was actually trying to do</h3><p>Looking back, that folder wasn’t stupidity. It was me, without the right tool, trying to solve a real problem by hand — trying to keep a history I could return to, trying to protect myself from my own mistakes.</p><p>Git was already built to do exactly that. I just hadn’t understood it yet.</p><p>If you’ve got a folder somewhere on your machine with a name like final2_actual_thisone — and if you&#39;ve read this far, I&#39;d bet you do — that folder isn&#39;t proof you&#39;re bad at this.</p><p>It’s proof you needed Git. You just hadn’t met it properly yet.</p><p>Now you have it here.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=363615251d99" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why I’m Writing About Technology Before I Feel Ready]]></title>
            <link>https://medium.com/@yoshithkesari/why-im-writing-about-technology-before-i-feel-ready-12b27605d878?source=rss-c9373a907960------2</link>
            <guid isPermaLink="false">https://medium.com/p/12b27605d878</guid>
            <category><![CDATA[personal-essay]]></category>
            <category><![CDATA[self-improvement]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[student-life]]></category>
            <dc:creator><![CDATA[Yoshith Kesari]]></dc:creator>
            <pubDate>Tue, 30 Jun 2026 20:21:41 GMT</pubDate>
            <atom:updated>2026-06-30T21:26:12.279Z</atom:updated>
            <content:encoded><![CDATA[<h3>A 19-year-old’s confession about debugging, doubt, and finally deciding to hit publish.</h3><p>It’s 1:47 AM.</p><p>I just fixed a bug by adding a single comma.</p><p>Not a clever fix.</p><p>Not some breakthrough.</p><p>A comma.</p><p>I’d spent close to forty minutes convinced something was deeply, structurally wrong with my code. I reread the function five times, out loud at one point, like saying it slower would reveal the problem. I opened a few more tabs — which, statistically, never helps, but I do it anyway every single time, like opening the fridge again hoping something new appeared.</p><p>Then I saw it.</p><p>One comma.</p><p>Forty minutes.</p><p>I didn’t feel relieved.</p><p>I felt a little stupid, honestly, in the specific way where you can’t even be mad at anyone but yourself, so you just sit there in silence for a second, recalibrating.</p><p>I texted my roommate “found it” with no context. He didn’t ask. He’s used to this by now.</p><p>Instead of closing my laptop and pretending this never happened, like a reasonable person would, I opened a blank document and started typing about it.</p><p>That document became this.</p><h3>For years, I thought blogs like this belonged to people who’d already arrived.</h3><p>I had a picture in my head of who gets to write about technology.</p><p>Someone with years behind them.</p><p>Someone whose code worked the first time — or at least looked like it did from the outside, which I now realize is most of what “looking experienced” actually means.</p><p>Someone who never had to paste an error message into Google at midnight and quietly hope a stranger from 2016 had already solved it for them, in a thread with three replies, the last one saying “bump.”</p><p>I was not that person.</p><p>I once spent twenty-two minutes debugging a “missing module” error before realizing I’d been running the file from the wrong folder the entire time. I didn’t tell anyone that for a week. I’m telling you now, which feels like a strange kind of progress.</p><p>So I waited.</p><p>I told myself I’d start writing once I knew more. Once a project actually impressed someone who wasn’t my mom. Once I felt like I belonged in the conversation instead of quietly standing near the edge of it, nodding at words I’d have to look up later.</p><p>That feeling never really arrived on schedule.</p><p>I’m starting to think it doesn’t, for anyone. I think people just get tired of waiting for it and start anyway.</p><h3>Then I noticed what I actually enjoyed reading.</h3><p>The posts I kept coming back to weren’t always written by the most accomplished engineers I could find.</p><p>They were written by people who admitted things.</p><p>When something broke, they said so, specifically, including the embarrassing part — not “I encountered an issue” but “I deleted the wrong database and found out our backups hadn’t run in three weeks.”</p><p>When a decision turned out to be wrong, they explained why they’d made it anyway, under deadline, half-asleep, trusting a tutorial they hadn’t fully read.</p><p>A post about a failed side project taught me more than a polished success story, almost every time. Not because failure is interesting on its own — it usually isn’t, it’s mostly just tedious — but because it leaves a trail. You can follow someone’s actual thinking instead of the cleaned-up version they present after the fact.</p><p>Those are the posts I bookmark. I have a folder of them. It’s called, unimaginatively, “good ones.”</p><p>Somewhere along the way, I stopped thinking writing was something you did after reaching the destination, and started thinking it was more like leaving a trail of breadcrumbs for whoever’s a few steps behind you. Including, probably, me, in six months, having forgotten all of this.</p><h3>My browser is, right now, a genuine mess.</h3><p>I counted before writing this paragraph: thirty-one tabs.</p><p>A few are documentation pages I opened looking for one specific answer, scrolled through twice, and never found it, because it turns out the thing I needed was in a different version of the docs entirely.</p><p>A few are GitHub issues where someone describes my exact problem in painful, specific detail, and then the thread just stops. No resolution. The last comment is from 2021. Someone named xYzdev_throwawayXxYyZz says &quot;any update on this?&quot; and nobody ever answers them. I think about that person sometimes. I hope they figured it out.</p><p>There’s a YouTube video promising a two-minute fix that is, in practice, eleven minutes, four of which are the guy explaining why he started this channel.</p><p>There’s a Stack Overflow answer marked “Solved” where the actual fix is a single comment that says:</p><p><em>“nvm fixed it lol”</em></p><p>No further explanation. Just vibes.</p><p>Somewhere between the documentation tab I needed and the YouTube video I clearly didn’t, I realized I’d spent more time looking for a fix than I would’ve spent just rereading my own code from the top, slowly, like a person with patience.</p><p>I don’t have patience. That’s part of why I’m telling you this.</p><h3>Some projects turn into products. Some just turn into me, slightly different than before.</h3><p>I’ve built things that worked exactly the way I planned. Not many. A handful.</p><p>I’ve also built a lot of things that, generously, taught me something about myself instead.</p><p>There was one project — an automation tool I was sure would finally be the thing — where I had the architecture mapped out in a notebook before I’d written a single line of code. I’d already mentally drafted how I’d describe it later. That should have been my first warning sign. I’ve since learned that the more confident I feel before starting something, the worse week I’m probably about to have.</p><p>It didn’t catastrophically fail.</p><p>It did something slower and worse.</p><p>It almost worked.</p><p>Every fix uncovered a new problem hiding directly behind the old one, like one of those nesting dolls except every doll is also slightly on fire. Every late night ended with something a little closer to functional, and nowhere near actually functional.</p><p>At one point I genuinely considered just renaming the whole repo to abandoned and walking away with my dignity intact. I didn&#39;t. Mostly out of stubbornness, not virtue.</p><p>I don’t remember most of the technical details anymore.</p><p>I remember sitting on my floor at one in the morning, laptop open on my bed, seriously asking myself if this was the moment I quit.</p><p>I remember not quitting, mostly because quitting felt like more effort than continuing at that point.</p><p>It never became the thing I originally pictured. It became proof that I can sit with something difficult longer than I think I can, which turns out to be a more useful skill than whatever the original project was supposed to do.</p><h3>There’s a specific, slightly unhinged joy in code finally agreeing to work.</h3><p>The terminal stops complaining.</p><p>The output matches the thing that’s been living in my head for three days, half-formed, refusing to leave me alone even during unrelated conversations.</p><p>And somehow, I still don’t trust it.</p><p>I run it again.</p><p>Still works.</p><p>I run it a third time, slower, watching the screen like it’s about to confess something.</p><p>Only then do I let myself believe it, and even then, only about sixty percent.</p><p>I’ve laughed out loud, alone, at a terminal window, at 2 AM, for no audience, over something nobody else would understand without three paragraphs of context. I’m not even slightly embarrassed about that anymore. I used to be.</p><p>Nobody sees these moments. They’re not the kind of thing that goes on a resume. But they’re the actual reason I keep doing this, more than any of the reasons I’d give if you asked me in an interview.</p><h3>Why write any of this down instead of letting it disappear?</h3><p>I have hundreds of scattered notes by now.</p><p>Half-finished markdown files with names like notes2.md, which tells you exactly how organized I was that day.</p><p>A Notion page literally titled “fix later,” last edited four months ago, untouched since, monument to a problem I apparently decided to simply live with instead.</p><p>Code comments that say:</p><p>// don&#39;t touch this, I genuinely don&#39;t know why it works</p><p>— left as a warning to a future version of me who will, without question, touch it anyway, because I have never once respected a warning I wrote for myself.</p><p>Folders named:</p><p>final</p><p>final2</p><p>final2_actual</p><p>final2_actual_thisone</p><p>I’m aware this is a problem. I have not fixed it. Writing this paragraph is, in a weird way, the closest thing to therapy these folder names have ever gotten.</p><p>Somewhere inside all of that mess are lessons that took real hours to learn, and most of them would quietly evaporate if I didn’t put them somewhere on purpose. Not because they stopped mattering. Just because memory has a habit of sanding the hard parts smooth until you forget they were ever hard at all.</p><p>Writing slows that down.</p><p>It also exposes, embarrassingly often, the parts I didn’t actually understand as well as I thought I did while I was busy congratulating myself for solving them.</p><p>That part stings a little. It’s also, I think, the entire point of doing this publicly instead of in a private note no one will read.</p><h3>So. Day one.</h3><p>This isn’t a tutorial.</p><p>There’s no checklist at the bottom, no five-step framework, no promise that any of this changes your life by Tuesday.</p><p>It’s just an explanation for why I’m here, written by someone who, twenty minutes ago, was still deciding whether “crime scene” was too dramatic a comparison for a browser tab situation. (It’s not. I checked again. Still thirty-one.)</p><p>What comes after this will look different. Some of it technical. Some of it a full walkthrough of a project from the first bad idea to whatever it eventually limped into becoming. Some of it, probably, a far-too-detailed account of a bug that ruined a perfectly good Saturday.</p><p>I genuinely don’t know where this goes from here. Not in the calculated, “the uncertainty is the journey” sense people say in interviews. The actual, real sense, where I have no plan past this paragraph and I’m okay with that.</p><p>What I do know is that waiting to feel ready wasn’t getting me any closer to writing the first sentence. The only thing that ever got me closer was sitting down and writing a bad first draft, then a slightly less bad second one, then this.</p><p>So this is it.</p><p>Day one.</p><p>A blank page that isn’t blank anymore.</p><p>I’ll figure out the rest of it the same way I figure out everything else — badly, first, with way too many tabs open, and a comma I probably forgot somewhere in this very article.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=12b27605d878" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>