<?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 Shobha Bhat on Medium]]></title>
        <description><![CDATA[Stories by Shobha Bhat on Medium]]></description>
        <link>https://medium.com/@shobha.bhat36?source=rss-34c2fc501b15------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*7JrJsh7BnG3DvOjE</url>
            <title>Stories by Shobha Bhat on Medium</title>
            <link>https://medium.com/@shobha.bhat36?source=rss-34c2fc501b15------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 15:18:13 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@shobha.bhat36/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 Day My Button Got Confused About Its Own Colors]]></title>
            <link>https://medium.com/@shobha.bhat36/the-day-my-button-got-confused-about-its-own-colors-be458ce7525e?source=rss-34c2fc501b15------2</link>
            <guid isPermaLink="false">https://medium.com/p/be458ce7525e</guid>
            <category><![CDATA[reactjs]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[tamagui]]></category>
            <dc:creator><![CDATA[Shobha Bhat]]></dc:creator>
            <pubDate>Tue, 29 Sep 2026 13:01:02 GMT</pubDate>
            <atom:updated>2026-09-29T13:01:02.066Z</atom:updated>
            <content:encoded><![CDATA[<h4>ReactJS + Tamagui: Build apps that quietly adapt to light, dark, and everything your users actually prefer — no toggle required.</h4><p>Welcome back to my blog!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WXOSUXBfugNZ0ej3rhqjWw.png" /></figure><p>Let me tell you about a bug that taught me more about Tamagui than any documentation ever could.</p><p>I was building a chart component. Nothing fancy — just bars that needed to be a certain color depending on whether a value was “good” or “bad.” Simple, right? I reached for the obvious tool:</p><pre>import { styled } from &#39;tamagui&#39;</pre><pre>const Bar = styled(YStack, {<br>  backgroundColor: &#39;$green10&#39;,<br>})</pre><p>That works beautifully — right up until the moment I need to pick the color <em>in JavaScript</em>, before any styling happens. Like when I’m calculating something, or deciding which icon to render, or sending a color value into a canvas library that has no idea what $green10 even means.</p><p>Styling tokens are great when you’re describing <em>how something looks</em>. They’re useless when you’re trying to <em>make a decision in your code</em>. And that’s the moment I met useTheme().</p><h3>The hook that lets your logic “see” the theme</h3><p>Here’s the thing nobody tells you clearly enough: Tamagui’s theme isn’t just a styling convenience — it’s actual data, and useTheme() hands you that data as real values, live, inside your component body.</p><pre>import { useTheme } from &#39;tamagui&#39;</pre><pre>function StatusBar({ isHealthy }: { isHealthy: boolean }) {<br>  const theme = useTheme()</pre><pre>  const barColor = isHealthy ? theme.green10 : theme.red10</pre><pre>  return &lt;canvas style={{ background: barColor.val }} /&gt;<br>}</pre><p>Notice that .val. That trips almost everyone up the first time. theme.green10 isn&#39;t a plain string — it&#39;s a reactive token object. The actual color value, the thing you&#39;d hand to a &lt;canvas&gt; or a chart library or a console.log, lives at .val.</p><p>Think of it like asking a librarian for “the book on shelf 12.” She doesn’t hand you the shelf number — she hands you the book. theme.green10 is your librarian&#39;s answer; .val is what&#39;s actually printed inside.</p><h3>Why this matters more than it seems</h3><p>The quietly powerful part is that useTheme() is reactive. If the theme changes — say, the user flips to dark mode — your component re-renders, and theme.green10.val updates itself to whatever &quot;green&quot; means in the new theme. You don&#39;t write a single line of change-detection code. You just ask the hook, and it always tells you the truth about <em>right now</em>.</p><p>I used this to fix a bug where my toast notifications looked slightly wrong in dark mode — a hardcoded #22c55e green that clashed against the dark background instead of harmonizing with it:</p><pre>function useToastColor(variant: &#39;success&#39; | &#39;error&#39;) {<br>  const theme = useTheme()<br>  return variant === &#39;success&#39; ? theme.green10.val : theme.red10.val<br>}</pre><p>Now the toast asks the theme what “success green” means <em>today</em>, instead of assuming it knows.</p><h3>Enter the second character: the user’s actual preference</h3><p>Reading theme values is only half the story, though. The more interesting question is: <em>how does the theme even know</em> whether it’s light or dark in the first place?</p><p>By default, most apps hardcode it, or let the user pick manually with a toggle. But there’s a better first impression you can give someone — respecting the color scheme they’ve <em>already told their operating system</em> they prefer. That’s where useColorScheme() comes in, usually from react-native (Tamagui plays nicely with it since it&#39;s built for cross-platform apps).</p><pre>import { useColorScheme } from &#39;react-native&#39;<br>import { TamaguiProvider } from &#39;tamagui&#39;<br>import config from &#39;./tamagui.config&#39;</pre><pre>export default function App() {<br>  const systemScheme = useColorScheme() // &#39;light&#39; | &#39;dark&#39; | null</pre><pre>  return (<br>    &lt;TamaguiProvider config={config} defaultTheme={systemScheme ?? &#39;light&#39;}&gt;<br>      &lt;YourApp /&gt;<br>    &lt;/TamaguiProvider&gt;<br>  )<br>}</pre><p>That’s it. That’s the whole trick. useColorScheme() asks the operating system &quot;hey, what did the user pick in their settings?&quot; and Tamagui&#39;s defaultTheme prop happily obeys.</p><h3>But real apps need more than “obey once at startup”</h3><p>Here’s where the story gets a little more interesting. useColorScheme() isn&#39;t just a one-time read — it&#39;s <em>live</em>. If the user is looking at your app and their system flips from light to dark (maybe it&#39;s sunset and their OS auto-switches, maybe they just toggled it), your hook value updates. You can use that moment to actually switch themes on the fly, not just at boot:</p><pre>function ThemedApp() {<br>  const systemScheme = useColorScheme()<br>  const [theme, setTheme] = useState(systemScheme ?? &#39;light&#39;)</pre><pre>  useEffect(() =&gt; {<br>    if (systemScheme) setTheme(systemScheme)<br>  }, [systemScheme])</pre><pre>  return (<br>    &lt;TamaguiProvider config={config} defaultTheme={theme}&gt;<br>      &lt;YourApp /&gt;<br>    &lt;/TamaguiProvider&gt;<br>  )<br>}</pre><p>Now your app behaves the way people quietly expect modern software to behave: it just <em>knows</em>. No settings screen required, no “please pick light or dark” onboarding step. It follows the user’s lead, the same way their phone’s Messages app or Notes app does.</p><h3>Letting the user override the system, gracefully</h3><p>Of course, some people want to fight their OS. Maybe their system is dark but they want your app to stay light because that’s what feels right for reading. So the pattern that actually ships well in production combines both ideas — system preference as the <em>default</em>, with an explicit override that wins when set:</p><pre>function useAppTheme() {<br>  const systemScheme = useColorScheme()<br>  const [userOverride, setUserOverride] = useState&lt;&#39;light&#39; | &#39;dark&#39; | null&gt;(null)</pre><pre>  const activeTheme = userOverride ?? systemScheme ?? &#39;light&#39;</pre><pre>  return { activeTheme, setUserOverride }<br>}</pre><p>This little hook becomes the brain of your theming system. The system scheme is a whisper in the background; the user’s explicit choice, if they bother to make one, always shouts louder.</p><h3>The moral of the story</h3><p>useTheme() and useColorScheme() solve two different problems that feel similar but aren&#39;t:</p><ul><li><strong>useTheme()</strong> answers: <em>&quot;What does this color/token mean right now, inside my logic?&quot;</em></li><li><strong>useColorScheme()</strong> answers: <em>&quot;What does the user&#39;s operating system say they prefer?&quot;</em></li></ul><p>Put together, they let you build something that feels less like “an app with a dark mode setting” and more like an app that’s quietly, correctly paying attention — to the system, to the user, and to itself.</p><p>And the bug that started this whole story? Fixed in one line — swapping a hardcoded hex code for theme.green10.val. Sometimes the smallest fixes teach you the most about the tool you&#39;ve been using all along.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=be458ce7525e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Day My Panel Learned to Read the Room]]></title>
            <link>https://medium.com/@shobha.bhat36/the-day-my-panel-learned-to-read-the-room-9bbfb0ceca43?source=rss-34c2fc501b15------2</link>
            <guid isPermaLink="false">https://medium.com/p/9bbfb0ceca43</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[tamagui]]></category>
            <dc:creator><![CDATA[Shobha Bhat]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 16:36:01 GMT</pubDate>
            <atom:updated>2026-09-28T16:36:01.467Z</atom:updated>
            <content:encoded><![CDATA[<h4>A story about React, Tamagui, and building components that actually pay attention to their surroundings</h4><p>Welcome back to my blog!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N_QeTMekbyacNm2jCBerjw.png" /></figure><p>It started with a feature I was heads-down building — a settings screen with a handful of info panels scattered across it. Partway through, I noticed I kept rebuilding the same panel over and over: same padding, same border, same rounded corners, just retyped each time with slightly different colors for light mode and dark mode.</p><p>That’s when it hit me: this didn’t need to be a one-off. This could be pulled out into its own reusable component — something any screen in the app could reach for later, in any theme, without redoing the same plumbing every time.</p><p>I’d been putting off learning <strong>Tamagui</strong> for weeks — it kept showing up in my Twitter feed as “the fast, universal styling system for React and React Native” — but this felt like the perfect excuse. So I made coffee, opened a blank project, and decided to turn that repeated pattern into a single, theme-aware panel component.</p><p>This is the story of how that went.</p><h3>Chapter 1: Meeting Tamagui</h3><p>Before touching any code, I needed to understand what made Tamagui different from “just CSS-in-JS.” The pitch, as I understood it, boiled down to one idea:</p><blockquote><strong><em>Themes aren’t just colors. They’re a language your components can speak.</em></strong></blockquote><p>In plain CSS or even styled-components, “theme-aware” usually means you sprinkle props.theme.colors.primary everywhere and hope for consistency. Tamagui flips this — you define tokens once, and components reference <em>roles</em> like $background or $color, not literal hex codes. The component doesn&#39;t know if it&#39;s light or dark. It just knows &quot;give me the background,&quot; and the active theme answers.</p><p>Let’s set up the project and see this in action.</p><pre>npm create tamagui@latest</pre><p>This scaffolds a starter with a tamagui.config.ts file — think of it as the rulebook every component will consult.</p><h3>Chapter 2: Teaching the App Its Colors (Tokens)</h3><p>Every good story needs a vocabulary before it needs characters. In Tamagui, that vocabulary is <strong>tokens</strong>.</p><pre>// tamagui.config.ts<br>import { createTokens, createTamagui } from &#39;tamagui&#39;</pre><pre>const tokens = createTokens({<br>  color: {<br>    blue2: &#39;#eff6ff&#39;,<br>    blue2Dark: &#39;#0f1b2d&#39;,<br>    blue8: &#39;#93c5fd&#39;,<br>    blue8Dark: &#39;#2563eb&#39;,<br>    gray1: &#39;#ffffff&#39;,<br>    gray1Dark: &#39;#111111&#39;,<br>    gray12: &#39;#111111&#39;,<br>    gray12Dark: &#39;#f5f5f5&#39;,<br>  },<br>  space: { true: 8, small: 4, large: 16 },<br>  size: { true: 8, small: 24, large: 48 },<br>  radius: { true: 6, small: 4, large: 12 },<br>})</pre><p>Notice something: I’m not naming colors after <em>what they’re for</em> yet (“panelBackground”). I’m naming them after <em>what they are</em> (blue2, blue8). That distinction matters — it&#39;s the difference between a paint can and a paint job. The can just holds color. The theme decides where it goes.</p><h3>Chapter 3: Giving the App Two Moods (Themes)</h3><p>Now for the fun part — defining light and dark as two personalities that share the same vocabulary.</p><pre>const themes = {<br>  light: {<br>    background: tokens.color.gray1,<br>    color: tokens.color.gray12,<br>    panelBackground: tokens.color.blue2,<br>    panelBorder: tokens.color.blue8,<br>    panelColor: tokens.color.gray12,<br>  },<br>  dark: {<br>    background: tokens.color.gray1Dark,<br>    color: tokens.color.gray12Dark,<br>    panelBackground: tokens.color.blue2Dark,<br>    panelBorder: tokens.color.blue8Dark,<br>    panelColor: tokens.color.gray12Dark,<br>  },<br>}</pre><pre>export default createTamagui({<br>  tokens,<br>  themes,<br>  // ...fonts, media queries, etc.<br>})</pre><p>Here’s the part that clicked for me: background, color, and panelBackground are <strong>the same keys</strong> in both themes. That&#39;s the whole trick. A component that asks for $panelBackground doesn&#39;t need an if/else for light or dark — it just asks the question, and whichever theme is currently &quot;listening&quot; answers differently.</p><p>It’s like calling out “what’s for dinner?” in a house — the answer changes depending on who’s in the kitchen, but the question never does.</p><h3>Chapter 4: Building the Panel (Finally)</h3><p>With the vocabulary and personalities in place, the panel itself becomes almost boring to write — which is exactly the point.</p><pre>import { styled, YStack, Text } from &#39;tamagui&#39;</pre><pre>export const ThemedPanel = styled(YStack, {<br>  backgroundColor: &#39;$panelBackground&#39;,<br>  borderColor: &#39;$panelBorder&#39;,<br>  borderWidth: 1,<br>  borderRadius: &#39;$large&#39;,<br>  padding: &#39;$large&#39;,<br>  gap: &#39;$small&#39;,<br>})</pre><pre>export const ThemedPanelText = styled(Text, {<br>  color: &#39;$panelColor&#39;,<br>})</pre><p>Look closely at &#39;$panelBackground&#39; and &#39;$panelBorder&#39;. That dollar sign is Tamagui saying: &quot;don&#39;t hardcode this — go look it up in whatever theme is currently active.&quot; The panel has no idea if it&#39;s in dark mode. It just trusts the system.</p><p>Now let’s actually use it:</p><pre>import { TamaguiProvider, Theme, YStack } from &#39;tamagui&#39;<br>import config from &#39;./tamagui.config&#39;<br>import { ThemedPanel, ThemedPanelText } from &#39;./ThemedPanel&#39;</pre><pre>export default function App() {<br>  return (<br>    &lt;TamaguiProvider config={config}&gt;<br>      &lt;Theme name=&quot;dark&quot;&gt;<br>        &lt;YStack padding=&quot;$large&quot; backgroundColor=&quot;$background&quot; flex={1}&gt;<br>          &lt;ThemedPanel&gt;<br>            &lt;ThemedPanelText fontWeight=&quot;600&quot;&gt;Heads up&lt;/ThemedPanelText&gt;<br>            &lt;ThemedPanelText&gt;<br>              This panel adapts to whatever theme is watching it.<br>            &lt;/ThemedPanelText&gt;<br>          &lt;/ThemedPanel&gt;<br>        &lt;/YStack&gt;<br>      &lt;/Theme&gt;<br>    &lt;/TamaguiProvider&gt;<br>  )<br>}</pre><p>Change name=&quot;dark&quot; to name=&quot;light&quot;, and — without touching the panel&#39;s code at all — everything shifts. Same panel. Same file. Different mood entirely.</p><p>That first successful reload, watching the panel quietly change color and border without me writing a single conditional, felt genuinely satisfying. Like watching a kid tie their shoes for the first time without help.</p><h3>Chapter 5: The Plot Twist — Nested Themes</h3><p>Here’s where the story got more interesting than I expected. A few screens later, I ran into a new requirement:</p><blockquote><em>A “danger zone” panel needed red accents, even in light mode.</em></blockquote><p>My first instinct was to make a dangerPanel variant and prop-drill some boolean. But Tamagui had a cleverer answer already built in: <strong>themes can nest</strong>.</p><pre>&lt;Theme name=&quot;dark&quot;&gt;<br>  &lt;YStack backgroundColor=&quot;$background&quot; flex={1} padding=&quot;$large&quot; gap=&quot;$large&quot;&gt;<br>    &lt;ThemedPanel&gt;<br>      &lt;ThemedPanelText fontWeight=&quot;600&quot;&gt;Normal Panel&lt;/ThemedPanelText&gt;<br>      &lt;ThemedPanelText&gt;Everything is fine here.&lt;/ThemedPanelText&gt;<br>    &lt;/ThemedPanel&gt;</pre><pre>    &lt;Theme name=&quot;red&quot;&gt;<br>      &lt;ThemedPanel&gt;<br>        &lt;ThemedPanelText fontWeight=&quot;600&quot;&gt;Danger Zone&lt;/ThemedPanelText&gt;<br>        &lt;ThemedPanelText&gt;This action cannot be undone.&lt;/ThemedPanelText&gt;<br>      &lt;/ThemedPanel&gt;<br>    &lt;/Theme&gt;<br>  &lt;/YStack&gt;<br>&lt;/Theme&gt;</pre><p>As long as I define a red theme with its own panelBackground, panelBorder, and panelColor, that inner panel automatically overrides its parent&#39;s mood — while everything around it stays exactly as it was. No props passed. No conditionals. Just a wrapper announcing &quot;for anything inside me, different rules apply.&quot;</p><p>It reminded me of walking into a themed room at a party — the DJ doesn’t change for the whole house, just for that one room. Everyone downstream of that &lt;Theme&gt; tag hears the new music; nobody upstream even notices.</p><h3>Chapter 6: What I’d Tell Past Me</h3><p>If I were explaining this to myself from a month ago, mid-Slack-message-panic, here’s the short version:</p><ol><li><strong>Tokens are your raw materials</strong> — colors, spacing, sizes — named for what they are, not what they’re used for.</li><li><strong>Themes are recipes</strong> — they map the same set of <em>roles</em> (background, color, panelBackground) to different tokens depending on mood.</li><li><strong>Components should ask for roles, never raw values.</strong> $panelBackground, not #eff6ff. That single habit is what makes the whole system self-updating.</li><li><strong>Themes nest.</strong> You don’t need a separate variant system for “special sections” — just wrap them in their own &lt;Theme&gt;.</li></ol><p>The panel that started this whole story now sits happily in both light and dark mode, plus a “danger zone,” without me ever writing isDarkMode ? &#39;#111&#39; : &#39;#fff&#39; anywhere in the codebase. It just asks the room what mood everyone&#39;s in, and adjusts.</p><p>Which, if you think about it, is a pretty good way for anyone — component or otherwise — to move through the world.</p><p><em>If you build on this, a natural next step is exploring Tamagui’s </em><em>useTheme() hook for reading theme values inside logic (not just styles), or wiring theme switching to the user&#39;s system preference with </em><em>useColorScheme(). That&#39;s a story for another coffee.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9bbfb0ceca43" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Pair Programming and Code Review: A Practical Guide (Without the Hype)]]></title>
            <link>https://medium.com/@shobha.bhat36/ai-pair-programming-and-code-review-a-practical-guide-without-the-hype-9be0fd7881ca?source=rss-34c2fc501b15------2</link>
            <guid isPermaLink="false">https://medium.com/p/9be0fd7881ca</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-pair-programmer]]></category>
            <category><![CDATA[ai-programming]]></category>
            <dc:creator><![CDATA[Shobha Bhat]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 04:31:16 GMT</pubDate>
            <atom:updated>2026-09-28T04:31:16.760Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9f0XYMVbHj5PluV1JjQ2kw.png" /></figure><p>A few years ago, “pair programming” meant two people, one keyboard, and a lot of awkward silence while your partner tried to figure out why the build was failing. Now the second person in the room is often an AI. It doesn’t get tired, it doesn’t judge your variable names (out loud, anyway), and it can read your entire codebase faster than you can find the file you’re looking for.</p><p>But here’s the thing nobody tells you when you start: <strong>AI pair programming isn’t about typing less. It’s about thinking better, faster.</strong> Most people who get frustrated with AI coding tools aren’t bad programmers — they just haven’t figured out the rhythm yet. This guide is about that rhythm.</p><p>Let’s get into it.</p><h3>Part 1: AI Pair Programming</h3><h3>The mental shift you need to make first</h3><p>Before any tools or techniques, there’s one mindset change that matters more than everything else: <strong>stop treating the AI like a search engine and start treating it like a very fast, very knowledgeable, slightly forgetful junior engineer.</strong></p><p>A junior engineer can write good code if you give them good context. They can also confidently write the wrong thing if you just say “build the login page” and walk away. AI is the same. The quality of what you get back is almost entirely a function of the quality of what you put in.</p><p>Once that clicks, everything else in this guide makes sense.</p><h3>The three modes of AI pairing</h3><p>Not every coding session needs the same kind of AI involvement. There are three distinct modes, and picking the wrong one for the task is where a lot of frustration comes from.</p><p><strong>1. Driver mode — the AI writes, you steer</strong></p><p>You describe the outcome you want, the AI produces the code, and you review, correct, and guide. This is the mode most people think of when they hear “AI pair programming,” and it’s genuinely great for:</p><ul><li>Scaffolding a new feature or file structure</li><li>Writing boilerplate (API routes, form validation, config files)</li><li>Translating a spec or a Jira ticket into a first draft of code</li><li>Exploring an unfamiliar library or framework quickly</li></ul><p>Think of yourself as the tech lead in this mode. You’re not typing every character, but you’re absolutely responsible for what ships.</p><p><strong>2. Navigator mode — you write, the AI watches</strong></p><p>This is the Copilot-style experience: you’re typing the code yourself, and the AI is quietly suggesting completions, catching typos, or nudging you toward a cleaner pattern. This mode shines when:</p><ul><li>You know exactly what you’re building and just want to move fast</li><li>You’re working in a domain where you don’t fully trust AI’s judgment (security-critical code, tricky business logic)</li><li>You want to stay “in the code” mentally rather than context-switching to writing prompts</li></ul><p><strong>3. Rubber duck mode — you think out loud together</strong></p><p>Before you write a single line, you talk through the problem with the AI like you would with a colleague at a whiteboard. This is criminally underused. People jump straight to “write me the code” when the actual bottleneck isn’t typing — it’s figuring out the right approach.</p><p>Use this mode when:</p><ul><li>You’re debugging something weird and can’t find the root cause</li><li>You’re choosing between two or three architectural approaches</li><li>You’re not even sure what the “real” problem is yet</li></ul><p>Here’s a secret: just explaining your bug to the AI, in plain English, often makes you spot the issue yourself before it even responds. It’s the classic rubber duck effect — the AI just happens to be a duck that can also write code.</p><h3>Context is the whole game</h3><p>If you remember one thing from this entire article, make it this: <strong>AI pair programming lives or dies on context.</strong></p><p>A prompt like:</p><blockquote><em>“Write a function to parse CSV files”</em></blockquote><p>…will get you <em>something</em>. It might even work. But it won’t know:</p><ul><li>What error handling conventions your codebase uses</li><li>Whether you’re on Node, Python, or something else</li><li>Whether malformed rows should throw, skip, or log</li><li>What your existing CSV files actually look like</li></ul><p>Compare that to:</p><blockquote><em>“Here’s our existing </em><em>parsers/ folder and how </em><em>parseJSON.ts handles errors. Write </em><em>parseCSV.ts following the same pattern — it should skip malformed rows and log them to </em><em>warnings[] instead of throwing, since that&#39;s how the rest of the ingestion pipeline behaves.&quot;</em></blockquote><p>Same task. Wildly different output quality. This is why tools that can actually read your repository (Claude Code, Cursor, Copilot Workspace, etc.) tend to outperform copy-pasting into a chat window — they get the context automatically instead of you having to spoon-feed it every time.</p><p>If you’re stuck in a chat-based tool, do the spoon-feeding anyway. Paste in the relevant files. Explain the conventions. It feels slower in the moment and saves you an hour of cleanup later.</p><h3>Work in small, verifiable loops</h3><p>The biggest mistake people make with AI pair programming is asking for too much at once. “Build me the whole authentication system” sounds efficient. It isn’t. You end up with 400 lines of code you don’t fully understand, and when something breaks, you have no idea where to even start looking.</p><p>Instead, work in a loop:</p><ol><li><strong>Plan first.</strong> Ask the AI to propose an approach before writing any code. “Here’s the feature I need — don’t write code yet, just outline how you’d approach it.” This costs you thirty seconds and saves you from finding out, ten minutes in, that you were solving the wrong problem.</li><li><strong>Implement one piece.</strong> A function. A component. One logical chunk.</li><li><strong>Run it.</strong> Actually execute the code. Don’t just read it and nod.</li><li><strong>Feed back the real result.</strong> If it errors, paste the actual error message. If the output looks wrong, show the actual output. AI is far better at fixing a concrete, observed problem than guessing at hypothetical ones.</li><li><strong>Repeat.</strong></li></ol><p>This loop feels slower than “generate everything at once,” but it’s dramatically faster in practice, because you never end up debugging a giant pile of code you didn’t watch get built.</p><h3>You’re still the architect</h3><p>This is worth saying plainly: AI-generated code can be locally correct and globally wrong. It might write a function that works perfectly in isolation but duplicates logic that already exists elsewhere in your codebase, ignores your team’s error-handling conventions, or introduces a subtle security issue because it wasn’t told about a constraint that lives only in your team’s collective memory.</p><p>Your job doesn’t shrink with AI pairing — it shifts. You spend less time on syntax and boilerplate, and more time on:</p><ul><li>Is this the right approach for our system?</li><li>Does this handle the edge cases that actually matter for our users?</li><li>Is this secure, performant, and maintainable by someone other than me?</li></ul><p>Nobody else is going to ask those questions for you. Not yet, anyway.</p><h3>Don’t forget the tests</h3><p>When you ask for a feature, ask for its tests in the same breath. Something like:</p><blockquote><em>“Implement this function, and write tests covering the happy path, an empty input, and a malformed input.”</em></blockquote><p>AI is often better at <em>thinking of</em> edge cases than humans are, simply because it’s not anchored to “the way we usually use this.” But — and this matters — <strong>run the tests yourself.</strong> Don’t assume they’re correct just because they exist and pass. A test that always passes because it’s testing the wrong thing is worse than no test at all.</p><h3>Part 2: AI Code Review</h3><p>Code review is a different rhythm from pairing. You’re not building something from scratch — you’re looking at finished (or nearly finished) work and asking, “Is this actually good?” AI is a genuinely strong tool here, but only if you use it the right way.</p><h3>Think of it as a fast, tireless first pass — not the final word</h3><p>AI code review is excellent at catching the stuff that’s easy to overlook when you’ve been staring at your own code for two hours:</p><ul><li>Off-by-one errors and obvious logic bugs</li><li>Missing null checks or unhandled edge cases</li><li>Inconsistent naming or style compared to the rest of the file</li><li>Security footguns — unescaped user input, hardcoded secrets, unsafe SQL string concatenation</li><li>Code that’s more complicated than it needs to be</li></ul><p>Where it’s noticeably weaker: judging whether the <em>underlying approach</em> is right for your product, or whether a piece of business logic actually reflects what the business needs. That kind of judgment requires context about your users, your company, and your priorities — things that live in your head, not in the code.</p><p>The healthiest mental model: <strong>AI review is a really good pre-check before a human ever looks at it, not a replacement for the human.</strong></p><h3>Give it a job, not a vibe</h3><p>“Review this code” is a weak prompt. It’s the coding equivalent of asking a friend “So… what do you think?” about a fifty-page document. You’ll get a vague, scattered answer.</p><p>Instead, give the review a specific lens:</p><ul><li>“Review this only for security issues — injection, auth bypass, exposed secrets.”</li><li>“Check this diff against our existing conventions in utils/. Flag anything inconsistent.&quot;</li><li>“If a senior engineer on this team reviewed this PR, what would they push back on?”</li><li>“Assume this runs under high concurrency. What breaks?”</li></ul><p>Narrow, specific prompts consistently produce sharper, more actionable feedback than open-ended ones. This is true of humans too, if you think about it — a reviewer told “just look it over” gives a different review than one told “focus on the error handling.”</p><h3>Feed it the diff and the “why,” not just the code</h3><p>A code reviewer who only sees the final file, with no idea what changed or why, misses a lot. The same is true for AI. When you’re asking for a review, include:</p><ul><li>The actual diff (what changed, not just the final state)</li><li>A one- or two-sentence summary of the intent (“this fixes a race condition in the checkout flow”)</li><li>Any constraints that aren’t obvious from the code itself (“this has to stay backward-compatible with the v1 API”)</li></ul><p>This context turns a generic review into one that actually understands what you were trying to do — and can tell you whether you succeeded.</p><h3>Ask for reasoning, not a thumbs-up</h3><p>“Is this good?” invites a shallow, feel-good answer. Push for actual analysis:</p><ul><li>“Walk through what happens if this function receives malformed input.”</li><li>“What would break if two users hit this endpoint at the exact same time?”</li><li>“Is there a simpler way to write this that I’m missing?”</li></ul><p>You’re not looking for validation. You’re looking for someone (something) to find the hole in your thinking before your users do.</p><h3>Where this fits into a real workflow</h3><p>A few patterns that work well in practice:</p><ul><li><strong>Before you open a PR:</strong> run your diff past AI review first. Catch the embarrassing stuff — the leftover console.log, the unhandled null — before a human teammate ever sees it. This also just makes you a more considerate teammate; nobody loves reviewing a PR full of things a linter or a quick AI pass would&#39;ve caught.</li><li><strong>During review:</strong> use AI to draft review comments on a teammate’s PR, especially when you’ve spotted something but aren’t sure how to phrase it kindly. Just don’t paste its output verbatim — AI-written review comments can come across as blunt or oddly formal. Edit them so they sound like you.</li><li><strong>After merging:</strong> when you’re new to a codebase, ask AI to explain <em>why</em> a piece of code is written a certain way, especially if it looks unusual. It won’t always know the real history (sometimes the real answer is “someone left in a hurry in 2021”), but it can often infer the likely reasoning from the surrounding code, and that’s usually enough to get you unstuck.</li></ul><h3>The honest summary</h3><p>AI pair programming and AI code review both come down to the same underlying skill: <strong>knowing what context to give, and knowing what to check yourself.</strong></p><p>The people who get the most value out of these tools aren’t the ones who trust AI blindly or the ones who dismiss it entirely — they’re the ones who’ve built a good instinct for when to lean on it and when to slow down and think it through themselves. That instinct only comes from actually doing it, over and over, on real problems.</p><p>So the best next step isn’t reading another guide. It’s picking a small, real task — a feature you need to build or a PR you need to review — and running through the loops above, deliberately, until they stop feeling like a technique and start feeling like how you work.</p><p><em>Written as a practical field guide, not a product pitch — the goal is better habits, not brand loyalty to any particular tool.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9be0fd7881ca" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Propzilla — When Prop Drilling Turns into a Monster]]></title>
            <link>https://medium.com/@shobha.bhat36/propzilla-when-prop-drilling-turns-into-a-monster-85ede03eb406?source=rss-34c2fc501b15------2</link>
            <guid isPermaLink="false">https://medium.com/p/85ede03eb406</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[reactjs]]></category>
            <category><![CDATA[prop-drilling]]></category>
            <dc:creator><![CDATA[Shobha Bhat]]></dc:creator>
            <pubDate>Sat, 01 Nov 2025 13:41:37 GMT</pubDate>
            <atom:updated>2025-11-01T13:41:37.646Z</atom:updated>
            <content:encoded><![CDATA[<h3>Propzilla — When Prop Drilling Turns into a Monster</h3><p>I always wondered why people say prop drilling can make codebases <em>enormous</em> and <em>unreadable</em> — until I recently found myself knee-deep in one such situation. What started as a simple “just pass this down” quickly turned into a full-blown treasure hunt through layers of components 😅.</p><p>It was overwhelming, confusing, and a great reminder of how easily complexity can sneak in. But along the way, I picked up a few solid learnings that made the experience worth it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/1*ksUL6YIOIWoZrFJ0DoDuDw.png" /></figure><p>Prop drilling — that situation where you pass data through multiple layers of components that don’t actually need the data, just to get it to a deeply nested child — can quickly become an enormous and unreadable mess! I recently faced this exact dilemma, and I want to share my thoughts on just how overwhelming it makes the code, along with the valuable lessons I picked up solving it.</p><p>So, let’s dive in — and navigate this <strong>prop jungle</strong> together 🌿⚙️</p><blockquote>🔗 What is Prop Drilling?</blockquote><p>In React, <strong>prop drilling</strong> happens when you pass data from a parent component down through several layers of components in a component tree, even if the intermediate components don’t actually need the data themselves. They act merely as <strong>messengers</strong> or <strong>conduits</strong> to pass the data along to a deeply nested child component that <em>does</em> need it.</p><pre>function App() {<br>  const user = { name: &quot;Nick&quot; };<br>  return &lt;Parent user={user} /&gt;;<br>}<br><br>function Parent({ user }) {<br>  return &lt;Child user={user} /&gt;;<br>}<br><br>function Child({ user }) {<br>  return &lt;GrandChild user={user} /&gt;;<br>}<br><br>function GrandChild({ user }) {<br>  return &lt;p&gt;Hello, {user.name}!&lt;/p&gt;;<br>}</pre><p>Here, user is being passed through every level — App → Parent → Child → GrandChild. Only GrandChild actually needs it, but everyone in between has to carry it around.</p><blockquote><strong>👍 Bad vs. Good</strong></blockquote><p><strong><em>The Bad 👎</em></strong></p><ul><li><strong>Increased Complexity<br></strong>Makes the codebase difficult to read and debug. To find the source of a prop, you have to trace it through many files.</li><li><strong>Maintenance Nightmare<br></strong>Renaming or changing the type of a prop requires updating <strong>every single intermediate component</strong>, even though they don’t logically depend on that data. This increases the chance of bugs during refactoring.</li><li><strong>Tight Coupling<br></strong>Intermediate components become unnaturally coupled (tied) to their ancestors because they must accept and forward props they don’t need.</li></ul><p><strong><em>The Good 👍</em></strong></p><p>Prop drilling isn’t inherently evil, especially in shallow component trees.</p><ul><li><strong>Explicit Data Flow</strong><br>The flow of data is clear and follows standard React component architecture (unidirectional data flow).</li><li><strong>Simple Components</strong><br>For a component that only needs to pass a prop down one or two levels, prop drilling is the simplest and most performant solution.</li></ul><blockquote>🦄 <strong>Myth: Prop Drilling Encapsulates Data</strong></blockquote><p>Prop drilling does NOT encapsulate data.</p><ul><li><strong>Encapsulation</strong> means bundling data with the methods that operate on that data and restricting direct access to the component’s internal state.</li><li>Prop drilling, by its nature, <strong>exposes</strong> data to every intermediate component in the chain, even if they ignore it. This means the components aren’t truly independent or “black-boxed” because they are aware of and must handle the data they are forwarding.</li></ul><blockquote><strong>🚫 How to Avoid Prop Drilling</strong></blockquote><p>The general rule is: <strong>If a prop needs to travel more than 2 or 3 levels deep, consider an alternative.</strong></p><p>The primary way to avoid prop drilling in new code is to use the <strong>React Context API</strong> for application-wide or deeply shared state.</p><p>Instead of passing user down:</p><ol><li><strong>Create Context:</strong> Define a context object.</li><li><strong>Provide Value:</strong> Wrap the top-level component that holds the data with the Context Provider.</li><li><strong>Consume Value:</strong> The deepest component uses the useContext hook to grab the value directly.</li></ol><pre>const UserContext = createContext();<br><br>function App() {<br>  const user = { name: &quot;Nick&quot; };<br>  return (<br>    &lt;UserContext.Provider value={user}&gt;<br>      &lt;GrandChild /&gt;<br>    &lt;/UserContext.Provider&gt;<br>  );<br>}<br><br>function GrandChild() {<br>  const user = useContext(UserContext);<br>  return &lt;p&gt;Hello, {user.name}!&lt;/p&gt;;<br>}</pre><p>Create <strong>Custom Hooks</strong> — Centralise logic and make data accessible anywhere.</p><pre>function useUser() {<br>  const [user] = useState({ name: &quot;Nick&quot; });<br>  return user;<br>}</pre><p><strong>State Management Libraries</strong> — Tools like <strong>Redux</strong>, <strong>Zustand</strong>, or <strong>Recoil</strong> help when the app scales and many components need shared data.</p><blockquote><strong>🔨 How to Break the Existing Pattern</strong></blockquote><p>If you inherit a component tree suffering from severe prop drilling, you can refactor it using these strategies:</p><ol><li><strong>Introduce Context</strong><br>Identify the set of data that is being drilled and lift it into a dedicated <em>Context Provider. </em>This is the cleanest solution for deeply shared static or slowly changing data (like theme, user info, language).</li><li><strong>Component Composition</strong><br>Use the children prop or pass components as props. Instead of intermediate components forwarding data, the parent component that <em>has</em> the data can render the deeply nested component directly.<br> <br><em>Example:</em> Instead of Parent -&gt; Child1 -&gt; Child2(data), you structure it so Parent renders Child1 and passes the actual content as a prop: &lt;Child1 content={&lt;Child2 data={data} /&gt;} /&gt;. <br>This is great for reusable layout components.</li><li><strong>Lift State Up/Move State Down:<br></strong>If the data is only needed by two <em>sibling</em> components, lift the state up to their nearest common parent. If the data is only needed by a small, isolated branch, try to move the state definition down to the lowest possible component to reduce the scope of the problem.</li></ol><p><strong>Gradual Refactoring Steps</strong></p><ol><li><strong>Identify the most commonly drilled props</strong> (like user, theme, or settings).</li><li><strong>Move those to a Context Provider first.</strong> This immediately cuts the longest, most painful prop chains.</li><li><strong>Replace prop chains layer by layer</strong> — no need to rewrite everything at once. Tackle one deep chain at a time.</li><li><strong>Extract repeated logic into custom hooks.</strong> This simplifies components, reducing their reliance on props for logic execution.</li><li>Think of it as <strong>decluttering</strong> — you remove one unnecessary prop from one component at a time!</li></ol><blockquote>🔄<strong> What are the Alternatives?</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gMvklBg4bRcYRKThG9Omvw.png" /></figure><blockquote>✨ <strong>In short</strong><br>Prop drilling isn’t <em>bad</em> by itself — it’s just not scalable. For small trees, it’s fine. But as your app grows, it can quickly turn into a maze. Luckily, React gives us plenty of tools to navigate out of it!</blockquote><p>Hope this helped you in someways. Let me know if you want to know more about clean code practice for handling prop-drilling situation.</p><p>If you spot anything that could be improved or corrected, feel free to share your thoughts — I’m still learning too!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=85ede03eb406" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Getting Unstuck: Learning Jest with React Testing Library]]></title>
            <link>https://medium.com/@shobha.bhat36/getting-unstuck-learning-jest-with-react-testing-library-927cae6ea5ee?source=rss-34c2fc501b15------2</link>
            <guid isPermaLink="false">https://medium.com/p/927cae6ea5ee</guid>
            <category><![CDATA[jest]]></category>
            <category><![CDATA[react-testing-library]]></category>
            <dc:creator><![CDATA[Shobha Bhat]]></dc:creator>
            <pubDate>Tue, 30 Sep 2025 08:24:51 GMT</pubDate>
            <atom:updated>2025-09-30T08:24:51.297Z</atom:updated>
            <content:encoded><![CDATA[<p>When I first started working with React Testing Library, I kept running into confusion — especially around using Jest functions and configurations. Bit by bit, things started clicking for me, and I’d love to share what I picked up along the way…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Px_xVysDH2GAwTv_" /></figure><p>At the beginning of my journey with Jest, things got pretty messy with the reset and restore functions. Nothing seemed to work the way I expected — mocks weren’t resetting properly, tests kept failing intermittently, and I often got stuck because I was mixing up global mocks with local ones.</p><p>So it became crucial for me to really understand how and when to use these functions/configs.</p><p>Let’s break them down one by one, so we can get a clear picture of what they actually do and when they should (or shouldn’t) be used.</p><blockquote>🧹 jest.clearAllMocks()</blockquote><ul><li><strong>What it does:</strong> <br>Clears all mock usage data (like calls, instances, and results) for every mock in your test suite.<br> ✅ It <strong>does not reset the implementation</strong> — meaning the mock still behaves as you defined it.</li><li><strong>When to use:<br>- </strong>When you want a fresh call history between tests but keep the mock’s behaviour intact.<br>- Perfect if you’re testing multiple calls to the same function in different test cases.</li><li><strong>When <em>not</em> to use:</strong><br>- When you rely on call history across multiple tests<br>- When debugging flaky tests</li></ul><pre>// Imagine we mock a logger utility<br>const logger = { info: jest.fn(() =&gt; &quot;logged&quot;) };</pre><pre>test(&quot;logs once&quot;, () =&gt; {<br>  logger.info(&quot;first call&quot;);<br>  expect(logger.info).toHaveBeenCalledTimes(1);<br>});<br>test(&quot;logs again&quot;, () =&gt; {<br>  // Without clearing, this test would see the old calls too<br>  jest.clearAllMocks();<br>  logger.info(&quot;second call&quot;);<br>  expect(logger.info).toHaveBeenCalledTimes(1); // ✅ fresh count<br>  expect(logger.info()).toBe(&quot;logged&quot;); // implementation still works<br>});</pre><p>In jest.config.js, enabling clearMocks: true wipes mocks before each test. If you actually wanted to keep state, this setting can silently erase it.</p><blockquote>🔄 jest.resetAllMocks()</blockquote><ul><li><strong>What it does:</strong> Clears all information stored in every mock (calls, instances, results) and resets their implementation to undefined in a test suite.</li><li><strong>When to use:<br>- </strong>If you want a completely clean slate for mocks between tests.<br>- Helpful when the same mock is reused across different test cases.</li><li><strong>When <em>not</em> to use:<br>- </strong>If your mock has a custom implementation you want to keep. Resetting wipes it out.</li></ul><p>Say you’re mocking fetch in multiple tests:</p><pre>global.fetch = jest.fn();<br><br>test(&quot;fetches user data&quot;, async () =&gt; {<br>  fetch.mockResolvedValueOnce({ json: async () =&gt; ({ name: &quot;Alice&quot; }) });<br><br>  const res = await fetch(&quot;/user&quot;);<br>  const data = await res.json();<br><br>  expect(data.name).toBe(&quot;Alice&quot;);<br>});<br><br>test(&quot;fetches product data&quot;, async () =&gt; {<br>  // Without resetAllMocks, this test could accidentally reuse the above mock<br>  jest.resetAllMocks();<br><br>  fetch.mockResolvedValueOnce({ json: async () =&gt; ({ product: &quot;Book&quot; }) });<br><br>  const res = await fetch(&quot;/product&quot;);<br>  const data = await res.json();<br><br>  expect(data.product).toBe(&quot;Book&quot;);<br>});</pre><blockquote>🔁 jest.resetMocks() <strong>(global config option or manual)</strong></blockquote><ul><li><strong>What it does:</strong> Automatically resets state of mocks (calls, instances, etc.) before every test.</li><li><strong>When to use:<br>- </strong>When you want Jest to handle cleanup for you globally, without manually resetting mocks in beforeEach.</li><li><strong>When <em>not</em> to use:<br>- </strong>If you need mock call history to persist across multiple tests (rare, but sometimes in integration-like tests).</li></ul><p>In jest.config.js:</p><pre>module.exports = {<br>  resetMocks: true,<br>};</pre><p>Now before every test, Jest will reset mocks automatically:</p><pre>global.fetch = jest.fn();</pre><pre>test(&quot;test 1&quot;, () =&gt; {<br>  fetch.mockResolvedValueOnce(&quot;data&quot;);<br>  // Jest resets mocks here before moving to the next test<br>});<br>test(&quot;test 2&quot;, () =&gt; {<br>  // `fetch` is fresh, no leftover calls or implementations<br>  fetch.mockResolvedValueOnce(&quot;other data&quot;);<br>});</pre><p>Great for avoiding manual cleanup in every test file.</p><blockquote>♻️ jest.restoreAllMocks()</blockquote><ul><li><strong>What it does:</strong> Restores all mocks back to their original (real) implementation.</li><li><strong>When to use:<br>- </strong>When you’ve <em>spied</em> on a real function (e.g., jest.spyOn) and you want to restore it after the test.</li><li><strong>When <em>not</em> to use:<br>- </strong>If you’re working with plain jest.fn() mocks (since there’s nothing “real” to restore).</li></ul><p>Let’s say you’re spying on console.log:</p><pre>test(&quot;logs a message&quot;, () =&gt; {<br>  const spy = jest.spyOn(console, &quot;log&quot;).mockImplementation(() =&gt; {});</pre><pre>console.log(&quot;Hello World!&quot;);<br>  expect(spy).toHaveBeenCalledWith(&quot;Hello World!&quot;);<br>  // Restore the real console.log after test<br>  jest.restoreAllMocks();<br>  console.log(&quot;This will actually print again&quot;);<br>});</pre><p>Use it when you mock real functions with jest.spyOn and want them back.</p><blockquote>🛠️ jest.restoreMocks() <strong>(global config option or manual)</strong></blockquote><ul><li><strong>What it does:</strong> Automatically restores all mocks to their original implementations before each test.</li><li><strong>When to use:<br>- </strong>If you rely heavily on jest.spyOn and want Jest to clean things up automatically.</li><li><strong>When <em>not</em> to use:<br>- </strong>If you expect your mock to persist across tests (again, uncommon in unit tests).</li></ul><p>In jest.config.js:</p><pre>module.exports = {<br>  restoreMocks: true,<br>};</pre><p>Now spies are automatically restored:</p><pre>test(&quot;calls console.log&quot;, () =&gt; {<br>  const spy = jest.spyOn(console, &quot;log&quot;).mockImplementation(() =&gt; {});<br>  console.log(&quot;Test&quot;);<br>  expect(spy).toHaveBeenCalled();<br>});<br>// No need for jest.restoreAllMocks() - Jest will restore automatically</pre><p>Perfect for projects that rely on lots of spies.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hvsEVWEj_49PD8PPDvbbGA.png" /><figcaption>✅ Jest Reset, Restore &amp; Clear: Functions vs Config Options</figcaption></figure><p><strong>Key difference — clearAllMocks vs resetAllMocks:</strong></p><ul><li>clearAllMocks() → <em>keeps implementation</em> (your mock still “works”).</li><li>resetAllMocks() → <em>removes implementation</em> (mock returns undefined until you redefine it).</li></ul><p>⚡ <strong>Rule of thumb:</strong></p><ul><li>reset* → wipes mocks clean.</li><li>restore* → puts things back the way they were.</li></ul><p>I hope this breakdown makes things easier to understand. If you spot anything that could be improved or corrected, feel free to share your thoughts — I’m still learning too!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=927cae6ea5ee" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>