ABHIJAT
← Back home

Writing

Everything I’ve written

Notes on AI engineering, software systems, developer tools, and the lessons that only show up after you ship. 33 posts.

AI Engineering

What I learned building AI verification pipelines

Getting an LLM to check its own output is harder than it sounds. Notes on building verification pipelines that catch real errors.

7 min read2026-02RAGAS, OpenAI Evals, Evaluation

AI Engineering

Building reliable multi-agent workflows with LangGraph

Notes on structuring multi-agent LangGraph workflows so they stay debuggable in production, not just in a demo.

8 min read2026-01LangGraph, AI Agents, Prompt Engineering

AI Engineering

From prompts to production: making AI systems measurable

A prompt that works once isn't a system. Notes on turning ad-hoc prompting into something you can measure and trust.

9 min read2026-03Prompt Engineering, Evaluation, Production AI

Systems

Building a tiny operating system to understand computers better

Notes from writing ASH OS in C and x86-64 assembly, and what it taught me about the layers above the kernel.

10 min read2026-04Operating Systems, C, x86-64

Software Engineering

What production API optimization actually looks like

Performance work rarely looks like a single clever fix. Notes on where API latency actually goes and what moves the number.

6 min read2026-05APIs, Performance, Backend

Developer Tools

What I learned building developer tools

Notes on building small tools for developers — a VS Code extension, a packaging tool — and what makes them worth keeping open.

6 min read2026-06Developer Tools, VS Code, Electron

Developer Tools

Custom slash commands for the workflows I run every day

Claude Code's slash commands stop being a novelty once you write your own. Notes on which repetitive workflows are actually worth automating this way.

6 min read2026-07Claude Code, Developer Tools, Automation

Frontend

Shipping a small offline-first React Native app in a weekend

A simple notes app is a good stress test for whether you actually understand React Native's storage and navigation story, not just its components.

7 min read2026-07React Native, Mobile, Offline-first

Databases

The window functions that replace half your subqueries

A handful of SQL tricks that make correlated subqueries and self-joins mostly unnecessary, once they click.

4 min read2026-07SQL, PostgreSQL, Performance

AI Engineering

Why chain-of-thought prompts break under production load

Chain-of-thought reasoning helps accuracy on hard problems and quietly costs you latency, cost, and consistency at scale. Both things are true at once.

9 min read2026-07Prompt Engineering, Production AI, LLM

DevOps

Multi-stage builds that actually shrink your image size

The difference between a 1.2GB image and a 120MB one is usually one Dockerfile pattern, not a different base image.

4 min read2026-07Docker, DevOps, CI/CD

AI Engineering

Modeling agent retries as a graph instead of a loop

A while-loop with a retry counter works until the failure modes multiply. LangGraph's state machine model handles that better than it first looks like it should.

10 min read2026-07LangGraph, AI Agents, Reliability

Databases

Reading a query plan without panicking

EXPLAIN ANALYZE output looks intimidating until you know the four or five things it's actually trying to tell you.

6 min read2026-07PostgreSQL, SQL, Performance

DevOps

Caching node_modules correctly, and cutting CI time in half

The default GitHub Actions cache setup for a Node project usually isn't wrong, just incomplete in a way that quietly halves its usefulness.

3 min read2026-07GitHub Actions, CI/CD, Node.js

AI Engineering

Chunking strategy matters more than embedding model choice

Teams spend weeks benchmarking embedding models and an afternoon on chunking. The ratio should usually be reversed.

10 min read2026-07RAG, Embeddings, AI Engineering

Frontend

Narrowing unions without a wall of type guards

Discriminated unions do most of the narrowing work for you, if the union is shaped to let them.

4 min read2026-08TypeScript, Frontend

Backend

Why I stopped using field injection in Spring Boot

`@Autowired` on a field is the fastest way to wire a dependency and the easiest way to hide a circular dependency until it's a runtime surprise.

3 min read2026-08Spring Boot, Java, Backend

Developer Tools

Packaging a desktop app without losing a week to code signing

Electron's build tooling is genuinely good. Code signing on both platforms is where the schedule actually goes.

7 min read2026-08Electron, Desktop, Developer Tools

AI Engineering

Azure OpenAI vs OpenAI directly: what actually changes in your code

The model behavior is close to identical. Everything around it — auth, rate limits, deployment naming — is where the real differences live.

6 min read2026-08Azure OpenAI, AI Engineering, Cloud

Security

Cryptography basics every backend developer should actually know

You don't need to implement cryptography to write secure code. You do need to recognize the handful of mistakes that show up in almost every codebase.

11 min read2026-08Cryptography, Security, Backend

Databases

When a document model quietly becomes a relational one

MongoDB schemas start flexible and end up needing the same normalization discipline as a relational database, just without the tooling that enforces it.

7 min read2026-08MongoDB, Databases, Data Modeling

Systems

The Bash one-liners I actually use daily

Not a reference list of every possible flag. Just the handful that earn a spot in muscle memory.

3 min read2026-08Bash, Linux, Productivity

Frontend

The re-render you don't see coming from context providers

A context value that changes identity every render silently re-renders every consumer, even ones that don't look like they depend on it.

6 min read2026-08React, Frontend, Performance

AI Engineering

Building a golden dataset before you trust any eval number

RAGAS and OpenAI Evals both need something to evaluate against. The dataset you build that on matters more than which framework you pick.

9 min read2026-08RAGAS, OpenAI Evals, Evaluation

Cloud

Cloudflare Workers vs a traditional backend for small APIs

For a genuinely small API, the edge-function model removes more operational weight than it costs in flexibility. That trade flips as the API grows.

7 min read2026-09Cloudflare, Serverless, Backend

Systems

systemd units for a hobby project you don't want to babysit

The difference between a script you have to remember to restart and one that just comes back on its own is about fifteen lines of config.

4 min read2026-09Linux, systemd, DevOps

Security

Reverse engineering a file format with no documentation, patiently

Without a spec, the file itself is the spec. The process is slower and more methodical than it sounds from the outside.

10 min read2026-09Reverse Engineering, Security, Systems

AI Engineering

Jinja2 templates for LLM prompts instead of string concatenation

Prompt strings built with f-strings and concatenation get unreadable fast. A templating engine built for this exact problem already exists.

4 min read2026-09Jinja2, Prompt Engineering, Python

DevOps

Preview deploys as a real code review tool, not just a demo link

Every PR getting a live URL is usually treated as a nice-to-have for showing stakeholders. It's also one of the better code review tools available, underused as one.

3 min read2026-09Vercel, Code Review, DevOps

Backend

Node.js vs Python for a small AI backend — what actually decided it

Both handle the API layer fine. The deciding factor is usually the ML ecosystem, not the language itself.

6 min read2026-09Node.js, Python, Backend

AI Engineering

Streamlit for internal tools nobody else will ever see

Building a real frontend for a tool three people on your team will use is usually a waste of the time it costs.

3 min read2026-09Streamlit, Internal Tools, Python

Backend

MVC in a world of API-first backends — does the pattern still hold?

The view in MVC assumed a server rendering HTML. Most backends today don't. The pattern survives that shift better than it might seem.

6 min read2026-09MVC, Backend, Architecture

AI Engineering

Prompt chaining: breaking one big prompt into three small ones

A single prompt asked to do three things at once usually does all three worse than three prompts asked to do one thing each.

9 min read2026-09Prompt Chaining, Prompt Engineering, LLM