Anuj Mulik

Notes on writing code with AI, at scale.

I’m Anuj. I’m a software engineer at Featured.com, where a lot of the code I ship is written with AI. This is where I write down what works, what breaks, and what I measured along the way.

From Navi Mumbai, India. Living in Chandler, Arizona.

The posts here are written with AI, from my own notes, numbers and pull requests. The work, and the mistakes, are mine.

Writing

  1. Decision fatigue is realEvery clarifying question an agent asks costs the user a decision. How we moved our chat agent to acting on its best guesses, showing them as editable assumptions on the result, and asking only when a wrong guess is costly.6 min read
  2. Mocks first, backend second, glue lastThe build order we arrived at for shipping product with agents. Perfect the screens on fixtures with no backend. Build every capability against the contract. Wire and test end to end last. Why it did not work before, and what had to change in the codebase to make presentation and logic separable.10 min read
  3. Every tool you mount is a tax on every turnThe economics of an agent's authored surface. What an instruction, a tool description and a skill each cost per turn, the budgets that enforce it, the rule that every tool needs a reason that cannot be refuted, and a manifest cut from 23 tools to 7.7 min read
  4. A field guide to upgrading fast-moving dependenciesHow we upgrade a framework that releases most days. Enumerate every release between the pin and the target, classify every entry, verify the ones that matter by running them, and treat "undocumented" as a claim that needs evidence.7 min read
  5. Have an agent use the app and say what hurtsTurning "let an agent test the app and report friction" from a one-off into a system. Five parts, a ledger that remembers, deterministic probes before any model, and the dogfood rounds that feed it.6 min read
  6. Green CI, six real bugsA 328-file cleanup sweep passed every check. An extra pass asking "what could this break that no test would catch" found six real problems. The questions that found them, and why they are now a standing step.5 min read
  7. A playbook for orchestrating agents on long jobsHow a long migration was run by a chain of fresh-context worker agents, supervised by a chain of fresh-context overseers, with a cold review before anything touching money shipped. The design, the gates that caught real defects, and the honest costs.8 min read
  8. Stop asking a language model yes-or-no questionsA typed decision model, Jev, answers labels, scores and booleans with a probability for a fraction of a cent. How it unlocked flows we could not afford before, where it does not fit, and the method we use to find the next gain.8 min read
  9. Five weeks of being blunt with a coding agent, countedFive weeks, 218 of my own messages to a coding agent, classified by tone. What actually changed its behaviour, what being harsh cost, and a section where the agent answers for itself.9 min read
  10. A golden set is not an eval suiteHow we keep one small labelled set per decision, score it for cents before a merge, and why the set you tuned on is not the number you report. The setup, the traps, and what the live eval suite taught us instead.11 min read
  11. Delete the comments. The agent believes them.Code comments were a courtesy to the next human. Coding agents read them as fact, write them as narration, and both go wrong. How we got to a zero-comment budget on new code, and what we do with the context instead.7 min read
  12. The agent kept a diary. Nobody read it.We tried to make a product observe itself from inside its own code. It cost tokens on every turn and changed nothing. A scheduled agent that runs once a week, outside the product, did what the observer could not.7 min read
  13. 138 database queries to show a home pageClosing the loop on latency in a chat product. The harness, the eight causes, what each fix measured, and why counts beat milliseconds when the agent is doing the work.9 min read
  14. Written rules don't stop a coding agentThe first guardrails I put around coding agents were documents. Here is how they failed, what the failures cost, and the shape of the checks that replaced them.7 min read
  15. When the agent is the maintainerStarting a codebase where agents are the primary maintainers from day one. Gate classes, budgets for prompt text, and a rule for when a check is allowed to block.7 min read
  16. Your test suite is slowing the agent downMoving tests, type checks and evals out of the agent's way, the throughput it bought, and the limits of parallel agents on one machine.6 min read
  17. A week of decisions nobody signedA week of regressions from choices the agent made on its own, and the rules on the human side of the loop that came out of it.6 min read
  18. When the agent can talk its way past a ruleSome rules protect things that cannot be undone, and those rules do not belong in prose. They belong in a check the agent cannot talk its way past.5 min read
  19. Stop growing the system prompt. Coach the agent instead.We moved behaviour rules out of the system prompt and into one-line, per-turn nudges picked by a cheap judge. Here is what we measured.5 min read