Technical essays, architectural deep-dives, and practical guides at the intersection of code and design.
Page 2 of 30
A practical playbook for when your LLM/AI bill suddenly jumps: decompose the spike with the cost identity (requests × tokens-per-request × price-per-token), triage which factor moved, find the exact culprit — retry storms, context bloat, missing max_tokens, a model swap, a broken prompt cache — and fix it, plus how to stop the bleeding and prevent the next one.
How to make LLM applications fast and cheap: streaming and TTFT, shrinking the context, prompt caching, semantic caching, model cascades/routing, batching and quantization. The levers that cut perceived latency and cut cost 3–10× — with the arithmetic.
A plain-English glossary of the AI/LLM engineering vocabulary you keep hearing — evals, guardrails, RAG, agents, tokens, context window, embeddings, hallucination, tool calling, fine-tuning, LLM-as-judge and more. Every term pinned to where it lives in the LLM request pipeline, with why it matters.
How to build an AI coding-interview coach that actually prepares you for FAANG: never let the LLM decide whether your code is correct. Execute the candidate's code in a sandbox against hidden tests for a deterministic verdict, measure complexity empirically, and let the LLM only run the interview and score the subjective signals against an explicit rubric — with a real measured example and Python.
How to build an AI kundali chatbot whose results are actually correct: never let the LLM compute the chart. Use Swiss Ephemeris (pyswisseph) via tool-calling for deterministic, sub-arcsecond planetary positions, nakshatras and Vimshottari dasha, and let the LLM only extract birth details and interpret the exact numbers — with real computed output and Python.
How you actually fill a big order without moving the market against yourself: TWAP (even slices over time) and VWAP (slices that follow the volume curve). The Python to build both schedules, a simulated impact comparison, and why execution — not alpha — often decides whether a strategy makes money.
How much to bet is a bigger decision than what to bet on. The Kelly criterion, fixed-fractional sizing, and why betting past Kelly lowers your growth AND makes ruin near-certain — demonstrated in Python, with the measured reason professionals bet half-Kelly.
The HFT bread-and-butter signal, explained honestly: order-book imbalance — more size on the bid than the ask tilts the odds of the next price tick. The Python to compute it and test its predictive power, why it genuinely works, and why it's so hard to actually harvest.
The 'hello world' of algo trading — the SMA crossover — built as a clean vectorised backtest in pandas, with the full code, the metrics that matter (CAGR, Sharpe, max drawdown), and an honest result: on a 6-year test it lost to buy-and-hold, because a crossover is a trend filter, not an edge.
Momentum — owning what's been rising and stepping aside when trends roll over — explained and backtested in Python. Time-series momentum and breakouts, the full code, and the signature result: its edge is defensive, cutting a −39% buy-and-hold drawdown to −25% by going to cash in crashes.
Trade the spread, not the market: how pairs trading uses the z-score of two cointegrated assets to go market-neutral. The full Python — hedge ratio, spread, z-score, entry/exit at ±2σ — plus an honest look at why it works on paper and where it breaks (cointegration decay).
How market makers earn the spread by quoting both sides of the book — and why inventory is the risk that can wipe out every spread they capture. A toy market maker in Python, and the single most important control: skewing your quotes against inventory (measured: |max inventory| 90 → 3).