I build the systems I support, not just the tickets that come with them.

Change one instruction and the agent gets better at the case you were looking at, and quietly worse at four you weren't. Asserting on reply text doesn't help — there are twenty reasonable ways to say the same thing, so the suite breaks every time someone rewords a prompt.

Multi-turn conversations written as YAML, with assertions on what the agent did rather than what it said: which tool it called, with which arguments, whether that call actually succeeded, and what state the world ended in. It runs offline against a deliberately buggy demo agent, so the suite and CI cost nothing and never need an API key.

Every failure carries a mode, and the report ranks by mode rather than listing cases — thirty failures for one reason is a single fix. The headline check fails an agent that uses confident language with no successful tool call behind it: the caller hangs up satisfied, and nobody finds out until the thing that was “confirmed” doesn't happen.

Any monitoring tool can tell you the error rate spiked. During an incident that's rarely the hard part — the hard part is that five detectors fired and four of them are the same problem seen from different angles. Chase the latency regression and you lose twenty minutes on a downstream service that was fine until a client's expired token generated six times the normal load.

A CLI that parses JSON-lines, key=value and Common Log Format into one canonical event, runs seven independent detectors, then correlates the findings into ranked explanations — separating causes from consequences and marking the consequences as symptoms so nobody investigates them as separate problems. It also follows a single correlation id end to end, which is how you tell correct backoff from a client hammering a non-retryable status.

Every hypothesis states what would rule it out and ends in a concrete next check. Confidence is deliberately capped below certainty — this reads logs, and logs don't contain the deploy timeline or the change ticket. The sample incident ships with the repo as seeded synthetic data, so it runs from a clone.

Manual trade execution across fast-moving derivatives and forex markets is slow, inconsistent, and hard to run with discipline. I wanted systems that could take a strategy from signal to execution without emotion in the loop.

Two automated trading systems: one integrating with Zerodha's Kite Connect API for Indian options (F&O) trading, and another built on MetaTrader 5 for forex and metals — each handling data ingestion, signal generation, order execution, and risk controls.

Credentials and strategy parameters are kept out of the public repo; what's shared is the system architecture — data pipeline, execution logic, and risk management design — so the engineering is visible without exposing the live trading edge.