<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Hrushiekesh Kanjula Reddy — Blog</title>
    <link>https://hrushiekeshreddykanjula.com/blog</link>
    <description>Weekly engineering updates from recent commits and project progress.</description>
    <language>en-us</language>
    <atom:link href="https://hrushiekeshreddykanjula.com/blog/rss.xml" rel="self" type="application/rss+xml" />
    
    <item>
      <title>Stop Applying Tape: RCCA in Agentic Debugging</title>
      <link>https://hrushiekeshreddykanjula.com/blog/rcca-agentic-debugging</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/rcca-agentic-debugging</guid>
      <pubDate>Tue, 02 Jun 2026 00:00:00 GMT</pubDate>
      <description>AI agents are good at finding something that works. They are terrible at finding out why something broke. That is a discipline problem — and manufacturing solved it sixty years ago.
</description>
      <category>engineering</category>
      <category>ai-agents</category>
      <category>debugging</category>
      <category>root-cause-analysis</category>
      <category>software-engineering</category>
    </item>
    <item>
      <title>The Hidden Tax on Your AI: Context Windows, Skills, and the Cost of Attention</title>
      <link>https://hrushiekeshreddykanjula.com/blog/context-window-tokenization-skills-cost</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/context-window-tokenization-skills-cost</guid>
      <pubDate>Tue, 26 May 2026 00:00:00 GMT</pubDate>
      <description>Every skill you load, every message you send, every document you attach quietly eats into the same fixed budget. Here&apos;s what happens when that budget runs out — and how to spend it wisely.
</description>
      <category>ai</category>
      <category>context-window</category>
      <category>tokenization</category>
      <category>cost-optimization</category>
      <category>skills</category>
      <category>productivity</category>
      <category>developer-tools</category>
    </item>
    <item>
      <title>Running Multiple AI Agents in Parallel Without Destroying Your Codebase</title>
      <link>https://hrushiekeshreddykanjula.com/blog/parallel-ai-agents-file-locking</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/parallel-ai-agents-file-locking</guid>
      <pubDate>Mon, 25 May 2026 00:00:00 GMT</pubDate>
      <description>Two AI agents writing to the same file simultaneously is a data corruption event. Here is the file-locking orchestration layer that makes parallel AI development safe and fast.
</description>
      <category>ai</category>
      <category>multi-agent</category>
      <category>engineering</category>
      <category>architecture</category>
      <category>langgraph</category>
      <category>parallel-execution</category>
    </item>
    <item>
      <title>Governing AI Agents: Why Your LLM Needs a Constitution</title>
      <link>https://hrushiekeshreddykanjula.com/blog/multi-agent-ai-governance-manufacturing</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/multi-agent-ai-governance-manufacturing</guid>
      <pubDate>Mon, 18 May 2026 00:00:00 GMT</pubDate>
      <description>Giving an LLM access to your codebase without governance constraints is like hiring a contractor and handing them the master key on day one. Here is the governance framework that keeps multi-agent AI development safe and productive.
</description>
      <category>ai</category>
      <category>multi-agent</category>
      <category>llm</category>
      <category>governance</category>
      <category>engineering</category>
      <category>architecture</category>
    </item>
    <item>
      <title>AI Literacy: Knowing When to Prompt and When to Architect</title>
      <link>https://hrushiekeshreddykanjula.com/blog/ai-literacy-prompt-vs-architecture-engineering</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/ai-literacy-prompt-vs-architecture-engineering</guid>
      <pubDate>Mon, 11 May 2026 00:00:00 GMT</pubDate>
      <description>The highest-leverage AI skill in 2026 is not writing better prompts. It is knowing which problems need a prompt and which need a full architectural design. Here is the line I draw.
</description>
      <category>ai</category>
      <category>engineering</category>
      <category>architecture</category>
      <category>llm</category>
      <category>productivity</category>
      <category>essay</category>
    </item>
    <item>
      <title>Rotation Heuristics in SMT Assembly: Why We Still Guess, and How IPC-2581 Fixes It</title>
      <link>https://hrushiekeshreddykanjula.com/blog/rotation-heuristics-ipc2581-smt</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/rotation-heuristics-ipc2581-smt</guid>
      <pubDate>Mon, 04 May 2026 00:00:00 GMT</pubDate>
      <description>A 180-degree rotation error on a polarized capacitor causes a short circuit. A three-tier heuristic system catches most of them. The IPC-2581 standard would make the whole problem obsolete.
</description>
      <category>smt</category>
      <category>manufacturing</category>
      <category>python</category>
      <category>ipc-2581</category>
      <category>heuristics</category>
      <category>pcb</category>
    </item>
    <item>
      <title>Simulating Physics in Python: Vacuum Nozzle Validation for SMT Assembly</title>
      <link>https://hrushiekeshreddykanjula.com/blog/smt-nozzle-physics-validation-asyncio</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/smt-nozzle-physics-validation-asyncio</guid>
      <pubDate>Mon, 27 Apr 2026 00:00:00 GMT</pubDate>
      <description>Every component on a PCB has a physical body width. Every nozzle has an outer diameter. If the nozzle is too large, it drops the part. Here is the 1,600-line async pipeline that validates this at scale.
</description>
      <category>python</category>
      <category>asyncio</category>
      <category>manufacturing</category>
      <category>smt</category>
      <category>physics</category>
      <category>validation</category>
    </item>
    <item>
      <title>Closed-Loop Manufacturing: Cross-Linking AOI and SMT Machine Telemetry</title>
      <link>https://hrushiekeshreddykanjula.com/blog/cross-linking-inspection-production-telemetry</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/cross-linking-inspection-production-telemetry</guid>
      <pubDate>Mon, 20 Apr 2026 00:00:00 GMT</pubDate>
      <description>An optical defect and the machine event that caused it happen minutes apart and live in separate databases. Time-windowing SQL joins close the loop — here is how.
</description>
      <category>sql</category>
      <category>manufacturing</category>
      <category>analytics</category>
      <category>aoi</category>
      <category>smt</category>
      <category>data-engineering</category>
    </item>
    <item>
      <title>The SQL Window Function That Saved Our Defect Attribution</title>
      <link>https://hrushiekeshreddykanjula.com/blog/sql-window-functions-data-interpolation</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/sql-window-functions-data-interpolation</guid>
      <pubDate>Mon, 13 Apr 2026 00:00:00 GMT</pubDate>
      <description>SMT machines log generic errors milliseconds before they log the component that caused them. A forward-fill CTE using SQL window functions bridges that gap — here is exactly how it works.
</description>
      <category>sql</category>
      <category>sqlite</category>
      <category>window-functions</category>
      <category>manufacturing</category>
      <category>data-engineering</category>
      <category>analytics</category>
    </item>
    <item>
      <title>From Raw Machine Logs to Predictive Maintenance: Time-Series Analytics in SMT</title>
      <link>https://hrushiekeshreddykanjula.com/blog/time-series-analytics-hardware-degradation</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/time-series-analytics-hardware-degradation</guid>
      <pubDate>Mon, 06 Apr 2026 00:00:00 GMT</pubDate>
      <description>Raw machine telemetry tells you what happened. Time-series analytics tells you what is about to happen. Here is how First-Pass Yield, rolling defect rates, and SQL-driven root cause analysis work together.
</description>
      <category>python</category>
      <category>sql</category>
      <category>time-series</category>
      <category>analytics</category>
      <category>manufacturing</category>
      <category>predictive-maintenance</category>
    </item>
    <item>
      <title>Parsing Nested XML from Flying Probe Testers into a Relational Database</title>
      <link>https://hrushiekeshreddykanjula.com/blog/xml-telemetry-relational-database-fpt</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/xml-telemetry-relational-database-fpt</guid>
      <pubDate>Mon, 30 Mar 2026 00:00:00 GMT</pubDate>
      <description>Flying Probe Tester XML files are massive, nested, and namespace-unstable. Here is the three-table relational schema and defensive parsing strategy that tames them.
</description>
      <category>python</category>
      <category>xml</category>
      <category>sqlite</category>
      <category>manufacturing</category>
      <category>testing</category>
      <category>data-engineering</category>
    </item>
    <item>
      <title>Fuzzy Matching AOI Defect Data to Your Component Library</title>
      <link>https://hrushiekeshreddykanjula.com/blog/fuzzy-matching-aoi-inspection-telemetry</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/fuzzy-matching-aoi-inspection-telemetry</guid>
      <pubDate>Mon, 23 Mar 2026 00:00:00 GMT</pubDate>
      <description>AOI machines generate defect reports with part numbers that almost match your library. Here is the dynamic parsing and fuzzy matching system that bridges that gap.
</description>
      <category>python</category>
      <category>fuzzy-matching</category>
      <category>aoi</category>
      <category>manufacturing</category>
      <category>inspection</category>
      <category>data-engineering</category>
    </item>
    <item>
      <title>Parsing the Unparseable: Adaptive BOM Ingestion for Customer Spreadsheets</title>
      <link>https://hrushiekeshreddykanjula.com/blog/adaptive-bom-ingestion-stochastic-files</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/adaptive-bom-ingestion-stochastic-files</guid>
      <pubDate>Mon, 16 Mar 2026 00:00:00 GMT</pubDate>
      <description>Customers send spreadsheets that look nothing alike. Hardcoded column indices fail on day two. Here is the four-step heuristic pipeline that handles anything.
</description>
      <category>python</category>
      <category>data-engineering</category>
      <category>excel</category>
      <category>bom</category>
      <category>heuristics</category>
      <category>manufacturing</category>
    </item>
    <item>
      <title>Normalizing 20,000 Components: The Data Pipeline Behind SMT Assembly Intelligence</title>
      <link>https://hrushiekeshreddykanjula.com/blog/bom-normalization-manufacturing-scale</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/bom-normalization-manufacturing-scale</guid>
      <pubDate>Mon, 09 Mar 2026 00:00:00 GMT</pubDate>
      <description>A 10kΩ resistor has at least eight names in the wild. Here is how a regex-driven normalization engine turns manufacturing chaos into a canonical data layer.
</description>
      <category>python</category>
      <category>data-engineering</category>
      <category>manufacturing</category>
      <category>regex</category>
      <category>smt</category>
      <category>bom</category>
    </item>
    <item>
      <title>Taming a 1,200-Line Python Function: State Management in Async Desktop Apps</title>
      <link>https://hrushiekeshreddykanjula.com/blog/python-state-management-async-ui</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/python-state-management-async-ui</guid>
      <pubDate>Mon, 02 Mar 2026 00:00:00 GMT</pubDate>
      <description>When your Python backend and JavaScript frontend share state across async WebSocket calls, things fall apart fast. Here is the architecture that fixed it.
</description>
      <category>python</category>
      <category>async</category>
      <category>state-management</category>
      <category>eel</category>
      <category>architecture</category>
      <category>manufacturing</category>
    </item>
    <item>
      <title>Why I Chose Eel Over Electron for a Factory-Floor Desktop App</title>
      <link>https://hrushiekeshreddykanjula.com/blog/eel-python-gui-edge-manufacturing</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/eel-python-gui-edge-manufacturing</guid>
      <pubDate>Mon, 23 Feb 2026 00:00:00 GMT</pubDate>
      <description>PyQt was too limiting, Electron was too bloated. Eel let me build a glassmorphism dashboard on constrained edge hardware — and I almost feel bad about how well it worked.
</description>
      <category>python</category>
      <category>eel</category>
      <category>electron</category>
      <category>gui</category>
      <category>edge-computing</category>
      <category>manufacturing</category>
    </item>
    <item>
      <title>SQLite in Production: WAL Mode and Concurrency on the Factory Edge</title>
      <link>https://hrushiekeshreddykanjula.com/blog/sqlite-wal-mode-edge-manufacturing</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/sqlite-wal-mode-edge-manufacturing</guid>
      <pubDate>Mon, 16 Feb 2026 00:00:00 GMT</pubDate>
      <description>Everyone told me SQLite wasn&apos;t a real production database. Then I enabled WAL mode, handled concurrent MES workloads, and stopped worrying.
</description>
      <category>sqlite</category>
      <category>python</category>
      <category>edge-computing</category>
      <category>database</category>
      <category>manufacturing</category>
      <category>concurrency</category>
    </item>
    <item>
      <title>Why I Killed My 240KB Excel Macro and Built a Full-Stack MES Instead</title>
      <link>https://hrushiekeshreddykanjula.com/blog/legacy-macros-to-full-stack-mes</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/legacy-macros-to-full-stack-mes</guid>
      <pubDate>Mon, 09 Feb 2026 00:00:00 GMT</pubDate>
      <description>Every manufacturing team has that one Excel macro — the one nobody touches. Here&apos;s why I finally killed ours and what I built instead.
</description>
      <category>python</category>
      <category>manufacturing</category>
      <category>full-stack</category>
      <category>smt</category>
      <category>mes</category>
      <category>vba</category>
    </item>
    <item>
      <title>Python Async Programming: asyncio, aiohttp, and When to Actually Use It</title>
      <link>https://hrushiekeshreddykanjula.com/blog/python-async-asyncio-aiohttp</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/python-async-asyncio-aiohttp</guid>
      <pubDate>Mon, 02 Feb 2026 00:00:00 GMT</pubDate>
      <description>asyncio is not a magic speed-up — it&apos;s a precise tool for a specific problem. Here&apos;s what it actually does, when it wins, and when it costs you more than it&apos;s worth.
</description>
      <category>python</category>
      <category>asyncio</category>
      <category>aiohttp</category>
      <category>concurrency</category>
      <category>engineering</category>
    </item>
    <item>
      <title>The Agentic Trio: Using Claude Code, Cursor, and Google Antigravity Together</title>
      <link>https://hrushiekeshreddykanjula.com/blog/agentic-workflow-claude-cursor-antigravity</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/agentic-workflow-claude-cursor-antigravity</guid>
      <pubDate>Mon, 26 Jan 2026 00:00:00 GMT</pubDate>
      <description>I spent months running Claude Code, Cursor, and Google Antigravity 2.0 side-by-side on real projects. Here&apos;s what the combined agentic stack actually looks like — and where it breaks.</description>
      <category>claude-code</category>
      <category>cursor</category>
      <category>google-antigravity</category>
      <category>agentic-workflow</category>
      <category>engineering</category>
      <category>ai-tools</category>
    </item>
    <item>
      <title>Welcome to My Engineering Blog</title>
      <link>https://hrushiekeshreddykanjula.com/blog/welcome</link>
      <guid isPermaLink="true">https://hrushiekeshreddykanjula.com/blog/welcome</guid>
      <pubDate>Mon, 19 Jan 2026 10:00:00 GMT</pubDate>
      <description>An intro to this space — what I&apos;ll be writing about, how the blog is generated, and what the assembly hub is.</description>
      <category>engineering</category>
      <category>portfolio</category>
      <category>claude-api</category>
    </item>
  </channel>
</rss>