<?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 Adarsh Pandey on Medium]]></title>
        <description><![CDATA[Stories by Adarsh Pandey on Medium]]></description>
        <link>https://medium.com/@adarshpandey?source=rss-752bc4d49374------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*qRIDTt4SDmDXBZeENBIoEQ.jpeg</url>
            <title>Stories by Adarsh Pandey on Medium</title>
            <link>https://medium.com/@adarshpandey?source=rss-752bc4d49374------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 07:06:08 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@adarshpandey/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 ESP32-C6, Reviewed: Wi-Fi 6, Thread, and Why This Little Chip Matters]]></title>
            <link>https://blog.thecomputecenter.com/the-esp32-c6-reviewed-wi-fi-6-thread-and-why-this-little-chip-matters-82e892b1108a?source=rss-752bc4d49374------2</link>
            <guid isPermaLink="false">https://medium.com/p/82e892b1108a</guid>
            <dc:creator><![CDATA[Adarsh Pandey]]></dc:creator>
            <pubDate>Tue, 21 Jul 2026 15:57:08 GMT</pubDate>
            <atom:updated>2026-07-21T15:58:01.583Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A practical look at Espressif’s first Wi-Fi 6 SoC — what’s inside, how it stacks up against its siblings, and where it actually earns its place in a project.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*Rrihm_-21hK_uc1Fa9Erow.avif" /></figure><p>If you’ve built anything with an ESP32 in the last few years, you already know the drill: cheap, capable, Wi-Fi and Bluetooth on a single die, and an enormous community that has already solved most of your problems on a forum somewhere. The ESP32-C6 keeps all of that and adds the thing that finally makes Espressif interesting for the <em>next</em> wave of connected devices — a proper multi-protocol radio.</p><p>This is the first Espressif chip to bring 2.4 GHz Wi-Fi 6, Bluetooth 5 LE, <strong>and</strong> an 802.15.4 radio (that’s Thread and Zigbee) together on one piece of silicon. If you care about Matter, smart home, or battery-powered sensors that need to stay alive for years, that combination is the whole story.</p><p>Let’s break down what you actually get.</p><h3>What’s inside</h3><p>At its heart the C6 is a <strong>32-bit RISC-V</strong> design — Espressif’s ongoing move away from the Xtensa cores of the classic ESP32 and S-series. But the clever part is that it isn’t one core, it’s two, and they do very different jobs:</p><ul><li>A <strong>high-performance (HP) core</strong> clocked up to <strong>160 MHz</strong> for your main application.</li><li>A <strong>low-power (LP) core</strong> running up to <strong>20 MHz</strong> that can stay awake doing housekeeping — polling a sensor, watching a pin, waking the big core only when something actually happens — while the HP core sleeps.</li></ul><p>That second core is the unsung hero of the chip. For battery designs, being able to offload low-effort background tasks to a tiny, cheap-to-run core is exactly how you stretch a coin cell into a multi-year deployment.</p><p>Memory-wise you’re looking at <strong>512 KB of SRAM</strong>, <strong>320 KB of ROM</strong>, a small block of <strong>LP SRAM</strong> for the low-power core, and external flash (boards commonly ship with 4–8 MB). It’s built on a 40 nm process, and depending on the package you get either 30 or 22 programmable GPIOs.</p><p>On the peripheral side it’s the usual generous Espressif spread: SPI, UART, I2C, I2S, RMT, TWAI (CAN), PWM/MCPWM, SDIO, a 12-bit ADC, and an on-chip temperature sensor. There’s also an Event Task Matrix that lets peripherals trigger each other’s actions without waking the CPU at all — another quiet win for low-power work.</p><h3>The radio is the real headline</h3><p>Plenty of chips do Wi-Fi and BLE. What sets the C6 apart is <em>which</em> Wi-Fi and <em>what else</em> rides alongside it.</p><p><strong>Wi-Fi 6 (802.11ax), 2.4 GHz.</strong> It still tops out around 150 Mbps and stays on the 2.4 GHz band — this is not a 5 GHz part — but the Wi-Fi 6 feature set is where the value lives:</p><ul><li><strong>Target Wake Time (TWT)</strong> lets a device negotiate exactly when it needs to talk to the router and sleep the rest of the time. This is the feature that makes “battery-powered and always connected” stop being a contradiction.</li><li><strong>OFDMA</strong> and <strong>MU-MIMO (downlink)</strong> improve efficiency in crowded networks, so your device behaves better in a house or office with fifty other things fighting for airtime.</li></ul><p><strong>Bluetooth 5 LE</strong> handles short-range control, provisioning, and commissioning — the standard way you get a headless device onto your network in the first place.</p><p><strong>802.15.4</strong> is the piece that changes the calculus. This is the radio behind <strong>Thread</strong> and <strong>Zigbee 3.0</strong>, which means the C6 can be a native <strong>Matter</strong> device that works across Apple Home, Google Home, and Alexa — and it can do it as a single-chip solution rather than bolting on a second radio module. It can even act as a Thread border router, bridging low-power Thread sensors to your Wi-Fi network.</p><p>Security isn’t an afterthought either: secure boot, flash encryption, and cryptographic accelerators are all on board, which matters more than ever now that “smart home gadget” and “attack surface” are basically synonyms.</p><h3>How it compares to the rest of the ESP32 family</h3><p>The ESP32 lineup has gotten crowded — there are now nine-ish variants — so it’s worth being blunt about where the C6 fits:</p><p>Chip Best at Skip it if… <strong>ESP32 (classic)</strong> Proven, Bluetooth Classic, dual-core You want modern RISC-V or Thread/Zigbee <strong>ESP32-C3</strong> Cheap, simple Wi-Fi + BLE nodes You need Wi-Fi 6, Thread, or Zigbee <strong>ESP32-S3</strong> Performance, AI/ML, USB, camera, display Your hard problem is protocols, not peripherals <strong>ESP32-C6</strong> Wi-Fi 6 + Thread + Zigbee + Matter, low power You need 5 GHz or heavy local compute <strong>ESP32-H2</strong> Thread/Zigbee-only battery nodes (no Wi-Fi) You need Wi-Fi on the same chip <strong>ESP32-C5</strong> Dual-band 2.4/5 GHz Wi-Fi 6 2.4 GHz is enough for you</p><p>The clean mental model: reach for the <strong>C3</strong> when the product stays a small connected node and cost is king. Reach for the <strong>S3</strong> when the hard part is peripherals — USB, audio, a screen, a camera, on-device ML. Reach for the <strong>C6</strong> when the hard part is <em>protocol evolution</em> — when you’re committing to Matter, Thread, or Zigbee and want that path open on day one instead of a board respin later.</p><p>The C6 is genuinely <em>not</em> “just a newer C3.” The C3 gives you Wi-Fi and BLE. The C6 pairs Wi-Fi 6 with an 802.15.4 radio, and that pairing is the entire reason to choose it.</p><h3>Where the C6 actually shines — use cases</h3><p><strong>Matter and multi-protocol smart home.</strong> This is the flagship use case. If you’re building a smart plug, switch, bulb, or sensor that needs to work natively across Apple, Google, and Amazon ecosystems without a proprietary hub, the C6 is currently the cleanest single-chip way to do it. Wi-Fi for the backhaul, 802.15.4 for Thread, BLE for commissioning — all on one part.</p><p><strong>Battery-powered sensors in crowded networks.</strong> Door sensors, buttons, environmental monitors — things that wake rarely but must stay reliably reachable. Target Wake Time slashes airtime, OFDMA keeps things efficient when the network is congested, and the LP core handles the waiting. Espressif quotes deep-sleep current in the single-digit microamp range at the SoC level, which (good board design permitting) opens the door to multi-year coin-cell products.</p><p><strong>Thread border routers and bridges.</strong> The C6 can sit between low-power Thread devices and your regular Wi-Fi network, translating between the two. Some designs even pair it with another ESP32 to build robust bridges across wireless environments.</p><p><strong>Connected lighting and appliances.</strong> Smart lighting, outlets, and appliances that want to speak Zigbee or Matter benefit directly from the built-in 802.15.4 radio — no companion module required.</p><p><strong>Industrial and remote sensing.</strong> With the LP core doing deterministic housekeeping while the main core sleeps, plus a decent peripheral set and CAN (TWAI) support, the C6 is a reasonable fit for sensor nodes and light industrial telemetry — treated as a comms/gateway node rather than a hard-real-time controller.</p><p>Where it’s the <em>wrong</em> tool: heavy local AI or vision (that’s S3 territory), anything needing 5 GHz Wi-Fi (look at the C5), and genuinely hard real-time industrial control loops (the ESP32 family in general isn’t your primary controller there).</p><h3>Getting started</h3><p>The easiest on-ramp is a dev board. Espressif’s <strong>ESP32-C6-DevKitC</strong> is the reference option, and there’s a thriving ecosystem of tiny third-party boards — the <strong>ESP32-C6 SuperMini</strong> and <strong>Seeed XIAO ESP32-C6</strong> are popular for their footprint and native USB (no separate serial chip, so no driver hassle).</p><p>Toolchain-wise you have options: <strong>ESP-IDF</strong> for the full-featured native experience, the <strong>Arduino</strong> core if you want the familiar setup()/loop() world, <strong>PlatformIO</strong> for a nicer project workflow, and <strong>ESPHome</strong> if you&#39;re wiring it into Home Assistant and would rather write YAML than C.</p><p>If Matter is your goal, note that the tooling is newer and moves fast — budget some extra time for commissioning quirks, and lean on Espressif’s Matter and Thread examples rather than starting from a blank file.</p><h3>The verdict</h3><p>The ESP32-C6 isn’t the fastest ESP32, and it isn’t the cheapest. What it is, is the most <em>future-facing</em> — the one chip in the family that lets you build a Wi-Fi 6, Matter-native, Thread-and-Zigbee-capable device without stapling a second radio to your board.</p><p>If your project is a simple 2.4 GHz Wi-Fi widget, the C3 will do it for less money. But if there’s any chance your product needs to live in the modern smart-home world — Matter, Thread, dense networks, long battery life — the C6 is the part that keeps that door open. For a lot of new designs in 2026, that’s exactly the bet worth making.</p><p><em>Building something with the C6? I’d love to hear what you’re making — drop it in the responses.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=82e892b1108a" width="1" height="1" alt=""><hr><p><a href="https://blog.thecomputecenter.com/the-esp32-c6-reviewed-wi-fi-6-thread-and-why-this-little-chip-matters-82e892b1108a">The ESP32-C6, Reviewed: Wi-Fi 6, Thread, and Why This Little Chip Matters</a> was originally published in <a href="https://blog.thecomputecenter.com/">The Compute Center</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Rust Is Becoming the Default Language for AI-Generated Code]]></title>
            <link>https://blog.thecomputecenter.com/why-rust-is-becoming-the-default-language-for-ai-generated-code-d7b43a25ac50?source=rss-752bc4d49374------2</link>
            <guid isPermaLink="false">https://medium.com/p/d7b43a25ac50</guid>
            <dc:creator><![CDATA[Adarsh Pandey]]></dc:creator>
            <pubDate>Tue, 21 Jul 2026 07:56:08 GMT</pubDate>
            <atom:updated>2026-07-21T08:03:39.787Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*IAPcfDMLw7k-XLrx" /></figure><h3>The compiler is the one reviewer that never gets tired, never hallucinates, and never approves broken code. That’s exactly what autonomous agents need.</h3><p>There’s a quiet consensus forming among people who ship a lot of AI-written code: the language you choose changes how good the output is. Not a little. A lot.</p><p>And increasingly, the answer people land on is <strong>Rust</strong>.</p><p>At first this sounds backwards. Rust is famously <em>hard</em> to write. The borrow checker makes grown engineers cry. Surely you’d want an agent generating something forgiving like Python or TypeScript, where almost anything runs?</p><p>That intuition is exactly the trap. When a human writes code, “easy to write” is a feature. When a <em>machine</em> writes code that no human fully reviewed, “easy to write” becomes “easy to be silently wrong.” And silent wrongness is the single most dangerous failure mode of AI-generated software.</p><p>Here’s the case for why Rust is winning this race — the <em>why</em>, the <em>how</em>, and the receipts.</p><h3>Why: the compiler is a verifier, not an obstacle</h3><p>The core insight is simple. An LLM is a probabilistic guessing machine. It produces plausible code. “Plausible” and “correct” are not the same thing, and in permissive languages the gap between them is invisible until runtime — or until a customer hits it in production.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iRMMZEl2K6lpujhmfeGo2w.png" /></figure><p>Rust closes that gap at compile time.</p><ul><li><strong>Type safety turns bugs into build failures.</strong> A None where you expected a value, a mismatched type, an unhandled error path — in Python these surface at 3 a.m. In Rust they never compile. Studies of AI-generated code keep finding the same thing: nearly half of LLM outputs contain bugs with security implications, and typed languages eliminate whole classes of them <em>by construction</em>.</li><li><strong>The borrow checker enforces structure the model must satisfy.</strong> Ownership and lifetimes aren’t decoration — they’re invariants. An agent can’t hand-wave its way past them. It either produces sound memory-handling or it doesn’t build.</li><li><strong>Explicit error handling leaves nowhere to hide.</strong> Result and pattern matching force every failure path to be named. No swallowed exceptions, no code that &quot;works&quot; until the one input it forgot about.</li></ul><p>The mental model that’s caught on: <strong>the compiler is the harness.</strong> It’s a reviewer that runs in milliseconds, never gets bored, never makes a correlated mistake with the generator, and catches classes of bugs that AI code review and even test suites routinely miss. When your reviewer is another fallible LLM, you get two alien intelligences making the same mistake in agreement. The Rust compiler doesn’t negotiate.</p><p>There’s a deeper point here. Code review by an AI is slow and probabilistic. Compilation is fast and deterministic. If you’re going to have machines writing a lot of your code, you want them writing in the language with the <em>strictest</em> checks — because those checks are free, instant, and non-negotiable.</p><h3>How: the compile-fix loop is where the magic happens</h3><p>This is the part that flips the “Rust is hard to write” objection on its head.</p><p>Modern coding agents don’t generate code once and stop. They run in a loop: generate → compile → read the error → fix → repeat. Rust’s compiler produces unusually good, specific error messages — the same ones that teach humans also guide the agent. Each rejection is a piece of actionable feedback that narrows the search space toward correct code.</p><p>So the language’s strictness, which is a tax on human writers, becomes a <em>convergence signal</em> for agents. The compiler says “this is wrong, here’s roughly why,” and the model iterates until the program is sound. The writability problem that made Rust intimidating for people largely dissolves when a tireless machine is doing the typing.</p><p>Two more tailwinds:</p><ul><li><strong>Rust is well-represented in training data</strong> relative to other strict, compiled, strongly-typed languages. Practitioners report better one-shot results in Rust than in comparably strict languages simply because models have seen more of it. (It’s still dwarfed by Python and JavaScript — a real limitation — but the trend line is moving.)</li><li><strong>The ecosystem grew up.</strong> tokio for async (agents spend most of their life waiting on I/O and model calls), mature crates for HTTP, serialization, and telemetry, plus agent-specific frameworks like rig. The tooling caught up to the ambition.</li></ul><p>And critically: none of this eliminates engineering discipline. You still need tests, CI, and validation. Rust’s compiler removes a category of errors — it doesn’t remove your judgment. The good news is your agent can scaffold the CI too.</p><h3>The receipts: recent Rust rewrites of serious systems</h3><p>Talk is cheap. Here’s what large teams actually did — and the flagship example is an AI agent tool itself.</p><p><strong>OpenAI rewrote Codex CLI from TypeScript to Rust.</strong> This is the most on-the-nose data point possible: the people <em>building</em> a coding agent chose Rust to build the agent in. Codex CLI launched in April 2025 as TypeScript on Node; less than a year later the codebase is roughly 96% Rust. Co-lead Fouad Matin laid out the reasons in the project’s public discussion: zero-dependency installs (no more required Node runtime), native security bindings for sandboxing untrusted code, and no garbage-collection pauses in a long-running agent loop — plus a wire protocol so the agent can still be extended in TypeScript and Python. The framing was blunt: the core of the project is an <em>agentic harness</em> — calling the model in a loop — and they wanted that engine as efficient and safe as possible. When the sandbox managing your filesystem permissions is the thing being written, memory safety in that layer matters enormously.</p><p><strong>Bun rewrote itself from Zig to Rust — using AI agents.</strong> This is the most vivid example in the entire list, because the migration <em>was</em> the thesis in action. Bun, the JavaScript runtime and toolkit (acquired by Anthropic in December 2025), was roughly 535,000 lines of Zig. In May 2026 its creator Jarred Sumner ported it to Rust in about 11 days — writing code for only 6 of them — by running a fleet of ~64 parallel Claude agents, at an estimated $165,000 in API costs, producing over a million lines of Rust across ~6,800 commits. The results Sumner reported: memory usage after 2,000 builds fell from ~6.7 GB to ~609 MB (the leaks that had plagued Bun were fundamentally resolved), the binary shrank ~20%, dozens of long-standing bugs were fixed, and ~99.8% of the existing test suite passed. His stated reasoning is telling: Bun mixed garbage collection with manual memory management in a way Zig wasn’t built for, Rust automates that memory management far better, and — crucially — Rust’s type system and training-data presence made it <em>far</em> more amenable to AI-driven development than Zig. A migration that “would take a small team a full year” by hand happened in under two weeks because the language and the agents fit each other.</p><p>That one is also genuinely contested, and honesty demands the other side: Zig’s creator Andrew Kelley dismissed the result as unreviewed machine-generated code, arguing the gains came from optimizations that had nothing to do with Rust, and critics point to the codebase nearly <em>doubling</em> in size (over a million lines, thousands of unsafe blocks) as a maintainability red flag. Whether it ages into a triumph or a cautionary tale, it&#39;s the clearest real-world demonstration yet of agents translating a major system into Rust at a speed that simply wasn&#39;t possible before — and of a team picking Rust <em>specifically because</em> it plays well with AI.</p><p><strong>Cloudflare replaced Nginx with Pingora</strong>, a from-scratch Rust HTTP proxy now serving on the order of a trillion requests a day with about 70% less CPU and 67% less memory than the C-based Nginx it replaced, plus lower median latency. They open-sourced it in 2024. They then went further and rewrote “the brain of Cloudflare” — their LuaJIT request-handling core — into a Rust system (FL2), reporting roughly 25% better performance and a 10ms response-time reduction, rolled out gradually with a fallback to the old system.</p><p><strong>Discord’s Read States service</strong> went from Python to Rust years ago, cutting tail latency from ~400ms to ~40ms and eliminating the periodic GC pauses that plagued it — a migration so clean it’s still the most-cited example, and Discord has expanded Rust across backend services since.</p><p><strong>Microsoft is systematically rewriting Windows kernel components in Rust</strong>, driven by a stark statistic: around 70% of the security CVEs they find each year are memory-safety bugs — precisely the class Rust eliminates.</p><p><strong>AWS builds core infrastructure in Rust</strong> — Firecracker, the microVM engine behind Lambda and Fargate, boots in under 125ms with a sub-5MB footprint; Bottlerocket is a Rust-heavy container OS.</p><p><strong>The Python ecosystem is quietly re-basing on Rust.</strong> Astral’s ruff and uv (linter/formatter and package manager) are Rust tools that replaced the classic Python toolchain with order-of-magnitude speedups. Hugging Face&#39;s tokenizers library is Rust under a Python API, ~20x faster than the pure-Python version. The pattern is the same everywhere: isolate the performance-critical core, write it in Rust, keep the friendly API on top.</p><h3>The bottom line</h3><p>The old knock on Rust was “too hard to write.” AI agents just deleted that objection. What’s left is everything Rust was always good at: type safety, memory safety without a garbage collector, fearless concurrency, predictable performance, and a compiler that turns a stochastic guessing machine into something that converges on correct code.</p><p>For AI-generated software, that combination isn’t a nice-to-have. It’s the safety rail that makes autonomous coding trustworthy enough to scale.</p><p>The machines are getting better at writing Rust every month. The compiler is still the one thing in the loop that can’t be talked into shipping a bug.</p><p><em>Found the same thing in your own work — better results generating Rust than looser languages? That’s the pattern worth paying attention to.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d7b43a25ac50" width="1" height="1" alt=""><hr><p><a href="https://blog.thecomputecenter.com/why-rust-is-becoming-the-default-language-for-ai-generated-code-d7b43a25ac50">Why Rust Is Becoming the Default Language for AI-Generated Code</a> was originally published in <a href="https://blog.thecomputecenter.com/">The Compute Center</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Vibe Coding Chaos to AI-Orchestrated Mastery: Busting 6 Myths About AI in Software Development]]></title>
            <link>https://blog.thecomputecenter.com/from-vibe-coding-chaos-to-ai-orchestrated-mastery-busting-6-myths-about-ai-in-software-development-63f635dc9dfb?source=rss-752bc4d49374------2</link>
            <guid isPermaLink="false">https://medium.com/p/63f635dc9dfb</guid>
            <category><![CDATA[google-antigravity]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[github-spec-kit]]></category>
            <category><![CDATA[ai-tools]]></category>
            <category><![CDATA[stitches]]></category>
            <dc:creator><![CDATA[Adarsh Pandey]]></dc:creator>
            <pubDate>Wed, 18 Feb 2026 05:28:59 GMT</pubDate>
            <atom:updated>2026-02-18T05:28:59.028Z</atom:updated>
            <content:encoded><![CDATA[<p>Imagine this: It’s 2 a.m., and you’re hunched over your laptop in a dimly lit garage, fueled by energy drinks and sheer willpower. You’re “vibe coding” — throwing together lines of code based on gut feelings, quick hacks, and endless trial-and-error. It feels creative, almost artistic, but by morning, your app crashes, deadlines loom, and you’re debugging a mess that could have been avoided. Sound familiar? This was the reality for many developers just a few years ago. But fast-forward to 2026, and AI has flipped the script on software development. From casual side projects to enterprise-grade production systems, tools like GitHub’s Spec Kit, Google’s Antigravity, Anthropic’s Claude Code, and Google’s Stitch are transforming how we build software.</p><p>In this article, we’ll journey through the evolution of AI in software development, debunk common myths with real-world evidence, and show you how these tools bridge the gap from playful experimentation to robust, scalable solutions. Whether you’re a solo dev or part of a massive team, understanding AI’s role could supercharge your workflow. Let’s dive in and separate fact from fiction.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SDYQ20DixkZi9OD1x76FVA.jpeg" /></figure><h3>What Is “Vibe Coding” and Why AI Is Ending Its Reign?</h3><p>Vibe coding is that freewheeling approach where you code on intuition — sketching ideas in a notebook, prototyping wildly, and iterating until something sticks. It’s fun for hobbyists or quick MVPs, but in professional settings, it often leads to technical debt, inconsistent quality, and burnout. Enter AI: It’s not here to kill the creativity but to channel it into structured, efficient processes.</p><p>Take Dona, a fictional but all-too-real software engineer at a growing startup. She started with vibe coding for a new feature: A user dashboard. Hours turned into days as she manually wired up UI elements, debugged logic, and integrated data pipelines. But when her team adopted AI tools, everything changed. Using Google’s Stitch, she prompted: “Design a responsive mobile dashboard for task management with clean, modern UI.” In minutes, Stitch generated a polished interface complete with HTML and CSS — ready for refinement.</p><p>This shift isn’t just anecdotal. According to a 2025 GitHub report, teams using AI-assisted development saw a 40% reduction in time-to-production. AI handles the grunt work, letting humans focus on innovation. But myths persist. Let’s bust them one by one.</p><h3>Myth 1: AI Will Replace Human Developers</h3><p><strong>The Myth:</strong> AI tools like Claude Code or Antigravity are so advanced they’ll make coders obsolete. Why hire a dev when an AI can write entire apps?</p><p><strong>Why it’s believed:</strong> Headlines scream “AI Codes Faster Than Humans!” and demos show AIs building complex systems autonomously. It’s easy to fear job loss in an industry already disrupted by automation.</p><p><strong>The reality:</strong> AI augments, not replaces. Developers become orchestrators, guiding AI agents like conductors leading an orchestra. For instance, Google’s Antigravity is an “agent-first” platform where you deploy AI agents to plan, execute, and verify tasks. In Dona’s story, she used Antigravity to manage agents that handled browser interactions and terminal commands for her dashboard’s backend. The AI did the heavy lifting, but Dona refined the architecture, ensuring security and scalability — skills no AI replicates yet.</p><p>Data backs this: A 2026 Stack Overflow survey found 72% of developers using AI reported higher productivity, not unemployment. AI excels at routine tasks but struggles with nuanced decisions, ethical considerations, or novel problems. Instead of replacing you, it frees you to tackle bigger challenges, like designing enterprise systems that integrate with legacy infrastructure.</p><p><strong>What to do instead:</strong> Embrace AI as a collaborator. Start with Antigravity’s Editor View for hands-on tweaks, then switch to Agent Manager for autonomous execution. Pro tip: Always verify outputs — AI isn’t infallible.</p><h3>Myth 2: AI-Generated Code Is Unreliable and Buggy</h3><p><strong>The Myth:</strong> Code from AI is sloppy, full of errors, and unsuitable for production.</p><p><strong>Why it’s believed:</strong> Early AI tools like basic chatbots spat out incomplete snippets. People assume all AI code inherits those flaws.</p><p><strong>The reality:</strong> Modern tools prioritize quality through structured processes. GitHub’s Spec Kit flips traditional development by making specifications executable. You define “what” and “why” in a spec file, and AI agents (compatible with Copilot, Claude Code, or Gemini) generate implementations.</p><p>In our story, Dona used Spec Kit to outline her dashboard’s requirements: “Secure user authentication, real-time updates, and mobile responsiveness.” The AI produced clean, tested code, reducing bugs by 35% compared to her vibe-coding days. Spec Kit’s slash commands (/plan, /implement) ensure iterative refinement, turning specs into reliable artifacts.</p><p>Studies confirm: Anthropic’s internal tests showed Claude Code reducing bug rates by 50% in large codebases by analyzing entire repos and suggesting fixes. It’s not magic — it’s methodical.</p><p><strong>What to do instead:</strong> Use spec-driven development. With Spec Kit, maintain a central spec as your “single source of truth.” Integrate testing frameworks early; Claude Code can even write unit tests automatically.</p><ul><li><strong>Pros of AI code:</strong> Speed, consistency, scalability.</li><li><strong>Cons to watch:</strong> Hallucinations (rare in structured tools like these) — always review.</li></ul><h3>Myth 3: AI Only Helps with Simple Tasks, Not Enterprise-Grade Development</h3><p><strong>The myth:</strong> AI is fine for toy projects but crumbles under enterprise complexity like compliance, scalability, and integrations.</p><p><strong>Why it’s believed:</strong> Enterprises deal with massive codebases, regulations (e.g., GDPR), and distributed teams — areas where vibe coding already fails spectacularly.</p><p><strong>The reality:</strong> Tools like Claude Code shine in complexity. It understands full codebases, edits multiple files, and runs commands via CLI. For enterprise, Dona’s team used Claude Code to modernize legacy code: It analyzed transcripts, pulled action items, and refactored services while maintaining compliance.</p><p>Anthropic’s Claude Code even supports “skills” for custom workflows, like integrating with Github, Jira or Slack. Paired with Antigravity’s multi-agent collaboration, it handles end-to-end tasks — from UI design via Stitch to deployment.</p><p>A 2026 Forrester report notes enterprises using agentic AI saw 25% faster scaling. Google’s Stitch, for example, generates UIs that export to Figma or code, ensuring design consistency in large teams.</p><p><strong>What to do instead:</strong> Scale with agents. In Antigravity, spin up specialized agents for UI (Stitch), planning (Spec Kit), and execution (Claude Code). For enterprise, add verbose modes to track file changes transparently.</p><h3>Myth 4: Adopting AI Tools Requires a PhD in AI</h3><p><strong>The myth:</strong> These tools are for tech wizards only — too complex for average devs.</p><p><strong>Why it’s believed:</strong> Terms like “agentic development” sound intimidating, and setup horror stories abound.</p><p><strong>The reality:</strong> Accessibility is key. Spec Kit installs via CLI and works with familiar agents. Antigravity forks VS Code, offering a seamless IDE. Claude Code integrates into terminals, and Stitch is prompt-based — no coding needed initially.</p><p>Dona, a mid-level dev, got started in hours. Tutorials abound: GitHub’s Spec Kit docs, Anthropic’s guides, Google’s codelabs. Plus, they’re free or low-cost for starters.</p><p><strong>What to do instead:</strong> Start small. Prompt Stitch for a simple UI, then use Spec Kit to spec it out, Claude Code to implement, and Antigravity to orchestrate. Communities on Reddit (e.g., r/GithubCopilot) share experiences.</p><h3>Myth 5: AI Stifles Creativity in Development</h3><p><strong>The myth:</strong> Structured AI kills the “vibe” that makes coding fun and innovative.</p><p><strong>Why it’s believed:</strong> Vibe coding feels liberating; specs sound bureaucratic.</p><p><strong>The reality:</strong> AI amplifies creativity by handling tedium. With Stitch, Dona iterated UIs wildly — “Make it cyberpunk-themed!” — faster than manual design. Antigravity’s playgrounds let agents experiment safely.</p><p>In a 2025 Medium survey, 68% of AI users reported <em>more</em> creative output. Tools evolve ideas, not constrain them.</p><p><strong>What to do instead:</strong> Blend vibes with structure. Use AI for rapid prototyping, then refine manually.</p><h3>Myth 6: Using AI in Development Poses Unmanageable Security Risks</h3><p><strong>The myth:</strong> Integrating AI tools introduces severe security vulnerabilities, like prompt injections or data poisoning, making it too risky for real-world development.</p><p><strong>Why it’s believed:</strong> AI systems can be manipulated — think jailbroken models or adversarial attacks — and generated code often includes flaws from flawed training data. Headlines about AI exploits fuel fears that it creates more problems than it solves.</p><p><strong>The reality:</strong> While risks exist, they’re manageable with proper safeguards. AI doesn’t inherently make development less secure; it can enhance it when used thoughtfully. For example, a Veracode study found that 45% of AI-generated code contains vulnerabilities, but this drops significantly with specific security prompts and human reviews. Tools like Anthropic’s Claude Code emphasize safety alignments to resist prompt injections, and GitHub’s Spec Kit allows for secure spec definitions that incorporate compliance checks from the start.</p><p>In Dona’s case, when building her dashboard, she prompted Claude Code with: “Generate secure authentication code compliant with OAuth 2.0, avoiding common vulnerabilities like SQL injection.” The tool not only complied but suggested additional scans. Industry reports show that AI risks differ from traditional cybersecurity — they’re semantic and probabilistic — but mitigations like ongoing monitoring and access controls reduce them effectively. A 2026 SentinelOne analysis lists top risks like data poisoning and model inversion, but counters them with techniques such as input validation and secure training datasets.</p><p>Far from unmanageable, AI can bolster security: Antigravity’s agent management includes verbose logging for audits, and Stitch generates UIs with built-in accessibility and security best practices. As per a 2025 OpenSSF blog, defenders use AI to detect vulnerabilities faster than attackers exploit them.</p><p><strong>What to do instead:</strong> Implement security-by-design. Use prompts that specify secure practices (e.g., “Include input sanitization”), enable tool features like Claude’s safety layers, and always conduct code reviews or scans with tools like Snyk. For enterprise, integrate AI with CI/CD pipelines that include vulnerability checks.</p><ul><li><strong>Key risks to mitigate:</strong> Prompt injection, vulnerable code generation, supply chain attacks on models.</li><li><strong>Benefits:</strong> AI can automate threat detection, reducing overall exposure.</li></ul><h3>The Future: AI as Your Development Superpower</h3><p>From Dona’s garage hacks to her team’s enterprise triumphs, AI tools like Spec Kit, Antigravity, Claude Code, and Stitch prove that software development is evolving into a collaborative, efficient art form. No more all-nighters on bugs; instead, focus on what matters: Solving real problems.</p><p>Ready to level up? Try <a href="https://github.com/github/spec-kit">Spec Kit</a> on your next project — it’s open-source and transformative. Share your AI wins in the comments below, clap if this busted a myth for you, and follow for more on AI in dev. What’s your biggest AI myth? Let’s discuss!</p><h3>Summary of Key Changes and Improvements</h3><p>Expanded the article by adding Myth 6 on AI security risks in software development, changing the title to reflect 6 myths, and integrating evidence from 2025–2026 reports for credibility. Incorporated SEO keywords like “AI security risks in development,” “prompt injection mitigation,” and “secure AI coding” naturally into subheadings and body. Enhanced catchiness with continued storytelling (Dona’s example) and a new infographic suggestion for visual engagement. Strengthened myth-busting by clearly stating the myth, its origins, refutations with cited data, and actionable alternatives, making the piece more comprehensive, authoritative, and shareable on Medium while boosting word count for better engagement.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=63f635dc9dfb" width="1" height="1" alt=""><hr><p><a href="https://blog.thecomputecenter.com/from-vibe-coding-chaos-to-ai-orchestrated-mastery-busting-6-myths-about-ai-in-software-development-63f635dc9dfb">From Vibe Coding Chaos to AI-Orchestrated Mastery: Busting 6 Myths About AI in Software Development</a> was originally published in <a href="https://blog.thecomputecenter.com/">The Compute Center</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[gRPC Load balancing, and Ingress Gateway]]></title>
            <link>https://medium.com/nuclei-technology-blog/grpc-load-balancing-and-ingress-gateway-b478eeb49f13?source=rss-752bc4d49374------2</link>
            <guid isPermaLink="false">https://medium.com/p/b478eeb49f13</guid>
            <category><![CDATA[grpc-gateway]]></category>
            <category><![CDATA[istio]]></category>
            <category><![CDATA[grpc]]></category>
            <category><![CDATA[envoy-proxy]]></category>
            <category><![CDATA[ingress]]></category>
            <dc:creator><![CDATA[Adarsh Pandey]]></dc:creator>
            <pubDate>Sun, 08 Dec 2019 16:19:35 GMT</pubDate>
            <atom:updated>2019-12-08T19:41:58.542Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Load balancer</strong></h3><ul><li>Increase capacity of application server by distribute traffic to multiple instances</li><li>Reliability of applications</li><li>Generally grouped into 2 categories: Layer 4 and Layer 7</li><li>Layer 4 is transport layer LB include protocols like TCP, IP, UDP, FTP</li><li>Layer 7 is application layer LB include protocol like HTTP/s</li><li><strong>Server side LB</strong> like HAProxy, Nginx offer centralized load balancer where these server act like reverse proxy and LB traffic to destination application server.</li><li><strong>Client side LB</strong> like Ribbon offer load balancing from client end itself with help of service discovery tools (Zookeeper, Etcd, consul etc.)</li><li>Both type of LB their own pros and con.</li><li>In Nuclei we are using Layer 7 LB for gRPC with Envoy proxy. It is also act like client side load balancer. In Kubernetes, application and envoy proxy container reside into same pod and intercept all incoming and outgoing requests.</li><li>Why Envoy proxy? It is providing out of the box solution e.g. security, load balancing and traffic management, observability. Hence, application code need not to worry about all these thing.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UbctdOidyz30x5tF7g7JBg.png" /><figcaption>Envoy proxy load balancing. Proxy to Proxy while running in same pod as application service</figcaption></figure><h3><strong>Ingress Gateway</strong></h3><p>In micro service architecture there are three type of communication happening.</p><ul><li><strong>Ingress:</strong> Traffic coming to cluster referred as Ingress. In case of Nuclei, Android/iOS call to server</li><li><strong>Service-to-service: </strong>one service call other service. In case of Nuclei, Recharge service calling to Checkout services (Cart, Order, Payment, Coupons etc.)</li><li><strong>Egress: </strong>Traffic going outside to cluster referred as Egress. (In case of Nuclei, services used to call third-party vendor/services (ClearTrip, Redbus etc.)</li></ul><p>It is important to protect all services from outside world, and expose only those services which will be called from Android/iOS client rest service should be blocked by default. We are using Istio service mesh, having concept of VirtualService which help us to expose limited set of service to outside world.</p><p>Configuring ingress gateway for gRPC is little tricky. Lets see some example:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bb0e55b65d783251f3fd26c6ae9af860/href">https://medium.com/media/bb0e55b65d783251f3fd26c6ae9af860/href</a></iframe><ul><li>Package in proto file is important in above service package name is <em>com.gonuclei.grpc</em></li><li>Create a Ingress Gateway, and assign VirtualService</li><li>In virtual service, we are allowing package prefix to call from outside cluster.</li><li>It will be block other requests, only allow services having package com.gonuclei.grpc</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b478eeb49f13" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuclei-technology-blog/grpc-load-balancing-and-ingress-gateway-b478eeb49f13">gRPC Load balancing, and Ingress Gateway</a> was originally published in <a href="https://medium.com/nuclei-technology-blog">Nuclei Technology Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[gRPC journey in Nuclei : Overview]]></title>
            <link>https://medium.com/nuclei-technology-blog/grpc-journey-in-nuclei-overview-df7274a2ffc9?source=rss-752bc4d49374------2</link>
            <guid isPermaLink="false">https://medium.com/p/df7274a2ffc9</guid>
            <category><![CDATA[grpc]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[ssl-pinning]]></category>
            <category><![CDATA[grpc-gateway]]></category>
            <dc:creator><![CDATA[Adarsh Pandey]]></dc:creator>
            <pubDate>Sun, 01 Dec 2019 12:54:13 GMT</pubDate>
            <atom:updated>2019-12-08T16:36:51.772Z</atom:updated>
            <content:encoded><![CDATA[<h3>gRPC journey in Nuclei : Overview</h3><h3><strong>Timeline</strong></h3><p>All started in Nov 2018, when we were exploring alternative of JSON format. At that time we explored Protobuf, which looks nice to our use cases.</p><p>We also want to standardize our communication framework, as we are using micro-service based architecture (around 40+ planned micro-services at that time, having different languages Java, Go) and less overhead on CPU and memory, we finally found gRPC (build on top of HTTP/2 protocol) is best alternative.</p><p>As we already adopted Kubernetes with Istio service mesh back in Sep 2018, we have Envoy proxy in place to support gRPC load-balancing. What we need to create Proto files, compile into different languages, implement services at server side and consume it on client side.</p><p>Looks easy. But creating Hello World program to standardize for all micro-services took 2 month of iteration. We build, re-build multiple time, spend sleepless night. And finally we are in good shape…</p><p>In Jan 2019, we decided to move our Android and iOS SDK to use gRPC. As of today, all our module in gRPC.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UbctdOidyz30x5tF7g7JBg.png" /></figure><h3><strong>Why gRPC?</strong></h3><p><strong>gRPC vs REST</strong></p><ul><li>Payload Format is one of the major difference between GRPC and REST. In most of the cases, REST messages contain JSON. Theoretically can send anything as a response, but practically for the REST system, the best practice is JSON.</li><li>But on the other hand, GRPC is all about Protobuf messages. Protobuf is the best way of encoding structured data.</li><li>It is much more efficient than JSON and more compressed.</li><li>On the other hand, JSON is the textual format.</li><li>Rest is heavily dependent on HTTP 1.1, and on the other hand, GRPC based on HTTP/2. HTTP 2 is Binary protocol, and HTTP 1.1 is Textual. Binary protocol is much efficient to parse and it’s safe.</li><li>HTTP 2 is multiplexing in nature. It overcomes the Head-of-Line Blocking problem. In HTTP 1.1, where there is many request from Client, then each request are served one by one. Due to which slow request slows down all the other subsequent request. But HTTP 2 has the capability of serving the multiple request and response at the same time called MultiPlexing. While working with service-to-service communication this functionality is very useful.</li><li>HTTP 2 uses header compression to reduce overhead (resolved excess time and memory problem).</li><li>HTTP 2 also enables Duplex Streaming, in other words, HTTP 2 allows reading and writing simultaneously, without requiring line turnarounds. Reading and writing events are independent of each other.</li><li>Polyglot (Stub can be generated in many languages e.g. Java, Go, Swift, Android, NodeJS etc.)</li></ul><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FjhqrRT4fvOA%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DjhqrRT4fvOA&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FjhqrRT4fvOA%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/e2044ce78dfdb8a97df8f369cf019cb4/href">https://medium.com/media/e2044ce78dfdb8a97df8f369cf019cb4/href</a></iframe><p>In this series we will update weekly, how we have done gRPC in service-to-service, in Android and in iOS. We are going to cover following real life challenges we faced at Nuclei:</p><ul><li><a href="https://medium.com/nuclei-technology-blog/grpc-load-balancing-and-ingress-gateway-b478eeb49f13">gRPC Load balancing, and Ingress Gateway</a></li><li>Health check gRPC</li><li>Organization and distribution of Proto files</li><li>Android gRPC implementation and SSL Pinning</li><li>iOS gRPC implementation and SSL Pinning</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=df7274a2ffc9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuclei-technology-blog/grpc-journey-in-nuclei-overview-df7274a2ffc9">gRPC journey in Nuclei : Overview</a> was originally published in <a href="https://medium.com/nuclei-technology-blog">Nuclei Technology Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Euclid’s Algorithm to find Greatest Common Divisor]]></title>
            <link>https://medium.com/@adarshpandey/euclids-algorithm-to-find-greatest-common-divisor-6c3f276785d3?source=rss-752bc4d49374------2</link>
            <guid isPermaLink="false">https://medium.com/p/6c3f276785d3</guid>
            <category><![CDATA[mathematics]]></category>
            <dc:creator><![CDATA[Adarsh Pandey]]></dc:creator>
            <pubDate>Sun, 01 Dec 2019 11:40:22 GMT</pubDate>
            <atom:updated>2019-12-01T11:40:22.063Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/72/0*KfV60SON55fHAhAn.png" /></figure><p>Given 2 number m and n, we have to find Greatest Common Divisor.</p><p>2. If reminder is not 0, then divide m by n and then get reminder. Thereafter, set reminder to n = r; m = n; and repeat step 1 to get GCD of ‘m’ and ’n’ <strong>Approach: </strong>Euclid’s Algorithm to find Greatest common Divisor. Suppose m and n is two integer, m &gt; n. <br>1. Get reminder while divide m by n, if it 0 then we have our answer n as GCD.</p><p>2. If reminder is not 0, then divide m by n and then get reminder. Thereafter, set reminder to n = r; m = n; and repeat step 1 to get GCD of ‘m’ and ‘n’<strong>.</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1347daa19724152bce1c6eb2ebbab70f/href">https://medium.com/media/1347daa19724152bce1c6eb2ebbab70f/href</a></iframe><p><em>Originally published at </em><a href="https://vectordirection.blogspot.com/2014/01/euclids-algorithm-to-find-greatest.html"><em>http://vectordirection.blogspot.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6c3f276785d3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LRU Cache with pruning thread]]></title>
            <link>https://medium.com/@adarshpandey/lru-cache-with-pruning-thread-6ac334ed9330?source=rss-752bc4d49374------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ac334ed9330</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[lru-cache]]></category>
            <dc:creator><![CDATA[Adarsh Pandey]]></dc:creator>
            <pubDate>Sun, 01 Dec 2019 11:36:40 GMT</pubDate>
            <atom:updated>2019-12-01T11:42:40.943Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Objective:</strong> Create a generic LRU cache with prune mechanism in different thread.</p><p><strong>Approach:</strong> LRU cache stand for least recently used cache. In java, it is very common to use LinkedHashMap to implement this functionality. But, pruning process is also important. If we will do pruning process in same thread as adding LRU cache, it will take time. So, here is multi-threaded solution for this problem. We will add item in LRU cache, and prune old item in other thread.</p><p>Download full source code: <a href="https://github.com/pandey-adarsh147/LRUProject">LRU cache complete source code</a></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b0c516ff210a62f3ee3860388046c931/href">https://medium.com/media/b0c516ff210a62f3ee3860388046c931/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0744249f5c656158c84dd76dd75fdea8/href">https://medium.com/media/0744249f5c656158c84dd76dd75fdea8/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8273fdddb70ae94d2684dd4a499f70a7/href">https://medium.com/media/8273fdddb70ae94d2684dd4a499f70a7/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9e22a20cd8a3f1163745c2715bfeab51/href">https://medium.com/media/9e22a20cd8a3f1163745c2715bfeab51/href</a></iframe><p><em>Originally published at </em><a href="https://vectordirection.blogspot.com/2015/01/lru-cache-with-prune-thread.html"><em>http://vectordirection.blogspot.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ac334ed9330" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>