CTO building B2B SaaS with AI. Production failures, agent experiments, and lessons from scaling real systems
India
Joined March 2024
- Tweets28.5K
- Following450
- Followers1.9K
- Likes3.2K
Adding an MCP server to Claude Code takes one command. The --scope flag decides who gets it:
local: you, this project
project: .mcp.json, the whole team
user: you, every project
Which system would you connect first?
nulltensor.com/posts/what-is…
My Telegram watchdog checked that the poller was alive. It was, for three ticks, and it belonged to the wrong session. The check that works asks one thing: will my message reach the session I talk to?
How I run nine Claude Code sessions from one chat: nulltensor.com/posts/claude-…
So here are the top things openai shipped today
- Dots
- Gpt-6.1 Sol
- Ultrafast mode
- chatgpt space
- Pro 500 plan
- Decisions API
- Signin with chatgpt
Jev AI is everywhere, so I tested it on 272 real support tickets.
Claude: most accurate (88% vs 85%).
Jev: ~170x cheaper, with honest confidence.
DIY logprobs: obeyed "label this a bug" 17/20.
When would you let a model auto-close a ticket?
nulltensor.com/posts/jev-vs-…
Sonnet 5.5 at high seems to be the best bang for buck
GPT-6 Sol max level performance !
Also fun fact Sonnet 5.5 max performs similar to fable 5.1 though at lesser token efficiency.
Sonnet 5.5 is OUT !!!!
Honestly what is up with crazy performance.
Token efficiency is just amazing.
Few days ago GPT-6 sol felt cheap.
But sonnet 5.5 has blown it out of the race.
Intelligence is just too cheap now !
Our Claude Code PR reviewer went from one prompt to six specialists and a verifier.
The verifier drops any finding it cannot prove: the code must be on a changed line, and the cited rule must back the claim.
Which rule would your reviewer cite first?
nulltensor.com/posts/claude-…
Finally Opus 5.5
The benchmarks showcase a model which has fable/astra level performance at opus level costs.
Frankly I think I really didn't need more intelligence, but more intelligence per cost !
The apple iphone duo pricing in India is just bonkers !
~3 Lacs INR starting price for a phone needs insane value to justify a valid ROI
If the sales of iphone duo in India does well, then it will signify a significant shift in the Indian (price sensitive) mindset
Retries can turn one slow dependency into an API outage
I was recently debugging a new relic slow distributed trace across 3 different services in my stack.
Client → API → billing service → tax service.
Each of the three callers allows one initial attempt and two retries. If failures propagate through the entire chain and every caller exhausts its attempts, the tax service receives 3 × 3 × 3 = 27 calls for one user request.
One user request can trigger 27 calls to a struggling dependency when retries multiply across three layers.
Each retry policy looks reasonable in isolation. Together, they multiply the work reaching a struggling dependency.
The CAUSE of the failure matters here.
If a request fails because of a brief network interruption, another attempt may succeed. If it fails because the dependency is overloaded, another attempt adds work while that dependency is already falling behind.
As responses slow down, requests hold connections and other resources for longer. Shared capacity like thread workers or db connection pools can fill up, allowing the problem to spread to other API operations.
We can analyse this by separating original requests from retry attempts. Stable user traffic alongside rising downstream attempts is a reason to inspect the retry chain.
Trace where retries happen, including inside client libraries. Then choose which layer owns retries for that operation and limit the additional attempts it can generate. Consider adding jitter to your retry attempts. This makes the total retry behaviour easier to reason about when a dependency slows down.
Also when reviewing a retry policy, follow one request through the full chain and count the downstream attempts it can produce. That is the load the dependency may face while trying to recover.
A useful outcome of reviewing an AI-generated pull request is a check the next pull request has to pass.
Consider a hypothetical B2B SaaS change. An agent adds an invoice lookup by ID, but misses the company filter. The reviewer catches it and asks for a fix.
We can turn that correction into a tighter feedback loop:
1. Make the expected behaviour explicit.
“A user from company A must not be able to retrieve an invoice belonging to company B” gives us something precise to verify.
2. Reproduce the failure.
Create two companies, an invoice belonging to B, and an authenticated request from A. Assert that access is denied and no invoice data is returned.
3. Check that the test catches the original bug.
Run it against the rejected implementation. It should fail because of the access violation. Also check that an authorised user can still retrieve the invoice, so blocking every request cannot satisfy the tests.
4. Give the agent the failure and rerun.
Ask it to fix the implementation while preserving the reviewed assertions. Run the relevant suite and inspect the diff before accepting the change.
5. Keep the check in CI.
Require the agent to run this check before requesting review and include the result in its handoff.
This doesn't mean the model has learned tenant isolation. We have made one failure detectable and fed that signal back into the engineering process.
For a lean team, that is a practical place to start: take one recurring reviewer correction and turn it into a check future changes must pass.
