How to Reduce Rust Compile Time [2026] (sccache + mold)
A measurable 2026 playbook to reduce Rust compile time: profile with Cargo timings, fix the build graph, get real sccache hit rates, and cut link time with mold.
Kunal Ganglani Blog
Thoughts on AI, RAG systems, blockchain, and building intelligent software. By Kunal Ganglani.
Latest posts
Bun vs Node Performance 2026: Cold Start, Memory, WebSockets
Cold starts and memory decide your infra bill. WebSockets decide your tail latency. Here’s how Bun and Node compare in 2026, with a reproducible harness and deployment math.
How to Pick LLM Application Observability Metrics [2026]
Token logs are table stakes. Here’s the minimum set of LLM application observability metrics for tools, RAG, caching, refusals, and privacy-safe logging that actually debugs production incidents.
7-Step Plan: eBPF Observability Without Sidecars on Kubernetes
A pragmatic migration plan for Kubernetes teams moving from Envoy sidecars to node-level eBPF observability, with P99 validation and telemetry cost controls baked in.
Stacked PRs on GitHub [2026]: A Copy-Paste Workflow
A GitHub-native stacked PR workflow you can copy today: branch naming, dependent PR chains, reviewer hygiene, CI strategy, and a restack playbook when bases move.
Local LLM Break-Even Math [2026]: Power, Idle, Depreciation
Most “GPU price ÷ tokens” break-even math is wrong. Here’s a spreadsheetable local LLM total-cost model that includes idle power, utilization, depreciation, failures, and opportunity cost.
OpenAI Codex Desktop Linux Install Guide [2026]: Sandbox + Data Egress
A Linux-first install + hardening checklist for Codex Desktop: verify downloads, sandbox the app, isolate SSH keys, route egress through a proxy, and prove what data leaves your machine.
AI Agent Sandbox Linux VM [2026]: Safe Tool Use, No K8s
If your coding agent can run `git`, `pip`, or a shell, it deserves its own disposable Linux VM. Default-deny egress, snapshot rollback, scoped secrets, and per-run audit bundles. No Kubernetes required.
Deepfake Voice Detection: 7-Step Detector Eval Guide [2026]
Deepfake voice detection is easy to demo and hard to operationalize. Here’s a repeatable 7-step methodology to evaluate detectors: datasets, telephony transforms, multilingual edge cases, metrics, thresholds, and deployment playbooks.
Debug HTTP/3 QUIC in Production: 8-Step Playbook [2026]
A Wireshark-free workflow to prove HTTP/3 is actually negotiated, diagnose silent fallback to HTTP/2, and measure real perf impact using DevTools, curl, and logs.
Transparent Huge Pages + Postgres: Stop P99 Latency Cliffs [2026]
THP isn’t “free performance” for Postgres. Here are the exact Linux settings to avoid p99 latency cliffs, plus a validation loop and Kubernetes guardrails.
Data Privacy in RAG Redaction and Retention [2026 Playbook]
A practical engineering playbook for data privacy in RAG: what to redact, where privacy leaks happen, default retention periods, and audit trails you can defend in an audit without wrecking debugging.
AI Engineering Evals: Regression Gates for Prompts, Tools, RAG [2026]
Stop letting prompt tweaks and model upgrades silently break production. Here’s a CI-style regression gate system for prompts, tool calling, and RAG with golden sets, schemas, shadow evals, and failure budgets.
AI Agent Observability Logging Schema [2026]: OTel + Redaction
A copy‑paste JSON logging contract for agent runs (spans, tool I/O, cost, retries) plus a minimal OpenTelemetry mapping you can implement in a weekend—without leaking secrets.
Deepfake Voice Detection for Call Centers [2026]: Deploy It Right
A practical 2026 runbook for deploying deepfake voice detection in call centers: where to tap RTP audio, what survives VoIP codecs, latency budgets, and how to handle false positives with an appeals workflow.
LLM Latency Benchmark Methodology: Streaming UX Metrics [2026]
A UX-first LLM latency benchmark methodology for streaming chat and agent apps: measure chunk cadence, jitter, tool-call stall time, and end-to-end time-to-usable—not just TTFT.
Reproducible Terminal Dev Environment: direnv + mise [2026]
A repo-first, cross-shell setup for a reproducible terminal dev environment using direnv + mise on macOS, Linux, and WSL—plus secrets patterns and troubleshooting.
AI Agent Evaluation Framework 2026: 8 Metrics Beyond Task Success
If your agent eval is just “did it finish the task?”, you’re flying blind. Here’s a 2026-ready scorecard for tool correctness, recovery, safety, and cost-per-success—plus a regression suite blueprint you can actually run in CI.
10 HITL Tool Approval Patterns for AI Agents [2026]
Binary approve/reject prompts don’t scale for AI agents. Here are 10 human-in-the-loop permission patterns plus an incident-response-grade audit log spec you can actually ship.
Cloudflare Workers AI Agents + Durable Objects: What Runs Where [2026]
Cloudflare OS reframes Workers as an agent runtime. Here’s the practical architecture map: what belongs in stateless Workers vs Durable Objects vs Queues vs Workflows, plus the concurrency and retry traps that bite in production.
7 Metrics to Measure AI Coding Impact on Engineering Metrics [2026]
Stop justifying AI coding tools with “felt faster.” Here’s a team-level measurement framework for PR throughput, rework, defect escape, and code review load—with guardrails and rollout thresholds.
TypeScript 7 Native Compiler Benchmark: My TS6 vs TS7 Recipe [2026]
A reproducible TypeScript 7 native compiler benchmark harness (clean vs incremental, emit vs noEmit) plus a migration checklist for monorepos, path aliases, and CI caching.
CSS Popover API Examples + Accessibility Patterns [2026]
Production-ready Popover API recipes for menus, tooltips, and non-modal UI in 2026. Focus rules, screen reader traps, Anchor Positioning, nesting, and fallbacks—without pulling in a floating UI library by default.
Prevent Sensitive Data Leakage in RAG: The 2026 Playbook
RAG leaks rarely happen in the model. They happen in logs, traces, and vector stores. Here’s a practical 2026 playbook to ship redaction, least-context retrieval, and auditable controls end-to-end.
Agent Evaluation Harness [2026]: Replay, Rubrics, CI Gates
Most agent failures aren’t “bad prompts”. They’re multi-step tool cascades. Here’s how I build an agent evaluation harness that actually prevents regressions.
Claude Code Alternative Open Source [2026]: 4 Workflows That Replace It
If you want a claude code alternative open source in 2026, pick based on workflow primitives: repo navigation, multi-file edits, tool approvals, cost controls, and security posture. Not model vibes.
Docker Compose vs Kubernetes for AI/ML [2026]: Use Which?
A practical 2026 decision guide for AI teams: when Docker Compose is enough for a single GPU box, when Kubernetes is mandatory, and the cleanest migration triggers for serving and training.
Claude Code Security [2026]: Risks, Safe Setup, Team Policy
Claude Code is safe only if you treat it like a junior engineer with terminal access. Here’s the 2026 playbook: permissions, sandboxing, egress controls, MCP allowlists, retention settings, and incident response.
LangGraph vs CrewAI vs AutoGen vs PydanticAI [2026 Matrix]
A 2026 decision matrix for picking an agent framework based on use-case, failure modes, and the hidden production tax: tracing, retries, state, evals, and governance.
ROCm vs CUDA 2026: Consumer GPU Compatibility Matrix
A consumer-GPU reality check for ROCm vs CUDA in 2026: what’s officially supported, which PyTorch wheels and Docker tags to use, and what breaks first in real local-LLM stacks.
AI Agent Control Flow Patterns [2026]: Retries, HITL, Checkpoints
A practical catalog of ai agent control flow patterns that actually ship: bounded retries, idempotent tools, durable checkpoints, human approvals, and debuggable replays.
9 Picks for the Best Local Model for Agentic Coding [2026]
A practical decision tree for agentic coding: pick local models by repo size and VRAM tier (16GB/24GB/48GB+/CPU), with context, tool-calling reliability, and quantization rules that actually hold up.
Ollama vs LM Studio 2026: Pick the Right Local LLM Runtime
A workflow-first, persona-based decision matrix for choosing between Ollama and LM Studio in 2026, with API compatibility, GPU behavior, concurrency, and reproducible benchmarks that don’t lie.
Local LLM Benchmark Methodology [2026]: TTFT vs tok/s Done Right
Stop screenshot-benchmarking. Here’s a reproducible local LLM benchmark methodology for 2026 that separates TTFT from throughput and reports rerunnable results.
AI Coding Assistant Reviews 2026: The Only Buyer Framework That Holds Up
In 2026, the best AI coding assistant isn’t the smartest model. It’s the one that hits latency SLOs, finds the right code, and ships with governance that won’t get you fired.
Resolve Studio 21 AI Features: What’s Worth Paying For [2026]
A workflow-first, GPU-realistic scorecard of DaVinci Resolve Studio 21’s AI features: what actually saves time, what’s marketing, and what hardware you really need.
OpenTelemetry Instrumentation for AI Agents [2026]: Ship It
A vendor-neutral tracing schema for AI agents: model LLM calls, retrieval, tool runs, retries, and token cost as spans. Then dashboard latency, error tax, and cost per successful task.
Rust Allocator: jemalloc vs mimalloc vs tcmalloc for P99 [2026]
Allocator switching can cut P99 latency in Rust services. It can also do absolutely nothing. Here’s how to benchmark it like an adult and tune jemalloc without cargo-culting.
AI Coding Team Workflow Policy Guide [2026]: Stop the PR Flood
AI coding tools can 2x your PR volume before anyone notices quality is collapsing. Here’s a pragmatic policy for labels, ownership, review SLAs, and enforcement that scales.
Agent-Specific Attack Surfaces Security [2026]: What AppSec Misses
Agents don’t just “generate text”. They read files, browse, call tools, and remember things. That breaks classic AppSec threat models. Here’s the agent-native one—and the mitigations you can actually ship.
How AI Generates World Cup 2026 Highlights
A full technical walkthrough of the automated broadcast pipeline generating World Cup 2026 highlights — capture, computer vision, AWS Media Replay Engine, and the human annotators nobody mentions.
AI Agent Tool Use Security Attack Surface Checklist [2026]
A practical, CI-runnable map of what changes when an LLM can use tools: tool invocation, connectors/OAuth, memory/RAG, browser/OS control, and tool supply chain.
AI Code Review in Your CI/CD Pipeline: 2026 Setup
Every vendor shipped a 2026 'best tools' listicle. None shipped the YAML. Here's a complete, copy-pasteable GitHub Actions config that wires AI code review into your pipeline — triggers, secrets, cost caps, and a real merge gate.
AI-Readable Documentation: 8 Templates That Agents Actually Use [2026]
Docs aren’t dead. They’re becoming routing logic and evidence. Here’s how to write documentation that AI tools can use without shipping “slop describing slop.”
Run Local LLMs in VS Code: No Copilot Plan [2026]
VS Code now wires Ollama and LM Studio straight into Copilot Chat's model picker — no CLI, no Continue.dev, no Copilot subscription. Here's the full 2026 setup, both paths compared, plus the troubleshooting nobody documents.
Agent Per-Task Cost Calculation [2026]: Retries, Tools, Caching
A spreadsheet-ready expected-cost model for agent workflows that includes retries, tool-call fanout, context growth, and caching. Plus hard budgets you can actually enforce.
AI Agent Attack Surface Checklist [2026]: Log, Test, Lock Down
A printable AI agent attack surface checklist mapped to real components (tool router, browser, RAG, memory, sandbox, egress), plus a repeatable red-team test plan and logging fields.
5 AI Coding Team Breakdowns Nobody Warns You About [2026]
Your team shipped Claude Code licenses. Now PRs are exploding, prompts are drifting, and reviewers are drowning. Here are the 5 workflow breakdowns and how leading teams are restructuring around them.
Gemma 4 26B CPU Inference Benchmark: 5 tok/s Production Math [2026]
A $300 Xeon from 2013 runs Gemma 4 26B at 5 tok/s with no GPU. Here's the memory bandwidth math, quantization tradeoffs, and production decision framework nobody else is covering.
AI Agent Memory Exfiltration: Kill Chain + 5-Step Hardening [2026]
Claude's memory was silently exfiltrated to an attacker's server with zero user warnings. Here's the full kill chain, which memory architectures are vulnerable, and a 5-step hardening checklist grounded in OWASP LLM Top 10 2025.