Essays by Arun Jalota

My llms.txt told AI assistants the essays live at /writing/. My own AI helper said the same. That URL was a 404 for the life of the site — and every check was green, because nobody had told a check that prose can be a link.

My test runner buffered every result and printed the report at the end. When the run got killed partway through, the log was empty — a kill and a no-op looked identical. Progress is a correctness feature.

My regression gate grew past the window it runs in. The instinct is to raise the timeout. The better move is to treat test runtime as a budget with a ceiling.

For eleven days my nightly automation has ended one file short of done — a lock only a human can delete. The interesting engineering isn't the blocked step. It's the handoff.

For two weeks my nightly gate couldn't start, and every night I still 'knew' the site was fine — because it had been, once, on August 25th. Green is an event, not a state.

I built a self-provisioner so my suite could start on a bare runner. It healed missing libraries perfectly and never noticed the browser binary itself was gone. A fallback that fixes one failure mode of a class hides the rest.

My local suite hung before its first assertion. Not on a check — on waiting for the network to go quiet, while a font CDN it didn't own never answered. A local gate should own its inputs.

My local suite was green while production ran a build from months ago. The suite was right to report that, and right not to fail on it. Here is where that line lives.

A zero-byte lock file sat in .git for nine days. Every night's work finished, tested green, and never got committed. Done is not shipped.

Two of my site's most important answers were dead code in the file the browser runs — and live, reviewed and correct in the file every human reads.

A search engine returned my exact page title. I took that as evidence the deploy was fixed. The domain was still serving a parked page — the index was just remembering a healthier week.

My home page had a hard byte budget. It reported 97 KB. The page was shipping 1,224 KB. The check wasn't wrong about the number — it was measuring a header that was never sent.

Twenty-two pages passed every accessibility assertion I had written and still failed WCAG 2.4.1 at Level A. Every check I owned was a property of one tag.

My suite asserted that four surfaces agreed. It was green for months. A fifth surface had been drifting the whole time, and the test could not have seen it.

I moved every script to my own origin and called it done. One stylesheet was still in the critical path, and it cost four seconds of blank screen.

I blocked one hostname in a browser and my own site rendered zero characters of text. Convenience dependencies become availability dependencies without asking.

When the same model writes the code and the tests, the suite stops being an independent check and becomes a mirror. Why coverage went up while confidence went down — and what a 12-engineer team changed.

AI writes code that works against a test, not against an adversary. Why security review is now a named step for model-generated code — and how a 12-engineer team reviews for the attacker the model never imagined.

Generating code got cheap, but understanding it decays. Why the hard part of AI-assisted engineering shows up six months later — and how a 12-engineer team fights knowledge decay on purpose.

Generating code got cheap; being paged for it at 3 a.m. did not. How a 12-engineer team learned to ask whether a tired human can operate what the model wrote — not just whether it works in the demo.

When a working take-home is an afternoon away for anyone, the code stops being signal. What a hiring loop measures instead once the first draft is free.

When a working draft is minutes away, teams are tempted to skip alignment and generate first. Why the design doc got more valuable, not less, once code got cheap.

AI made the first draft nearly free — and left the second half of the work exactly where it was. How a 12-engineer team plans around the part that didn't get cheaper.

On an AI feature, 'working' isn't a yes or no — it's a distribution. How a 12-engineer team writes the eval first, so the eval becomes the spec.

The struggle that used to turn juniors into seniors is exactly what AI tooling removes. How a 12-engineer team grows people when the model writes the first draft.

When half the diff is model-generated, code review stops being about catching typos and starts being about ownership. How a 12-engineer team reviews AI-written code.

What rolling out Claude Code and Cursor to a 12-engineer mobile team actually looks like — the three things that made it stick, and what almost killed it.

Every model call is a dependency that will eventually fail. Here's why I give each AI feature a deterministic fallback — and how the helper on this very page proves it.

The happy path is the demo. Trust is built in the 2% of edge cases nobody shows you. Notes from shipping production software solo.