Tech Lead & AI Engineer · London

From a student search portal to code that comes alive.

Sixteen years building software for regulators, clinical research and global finance, and now for the agents that build software too. This page is that journey, one chapter at a time.

Open to new roles On-site · Hybrid · Remote
Start the journey ↓

The journey

Eight chapters. One habit: ship the real thing.

Each stop changed how I build. Tap any project along the way to see its own story: the problem, my approach and what it taught me.

0years building software
0leading at ISB Global (2019–2026)
0commits on Vive in 7 weeks
0products I've built myself

My way of work

Hard problems I've solved, and how I approach new ones.

Enterprise software rarely fails on the happy path. It fails on the scenario nobody planned for, the legacy system nobody can switch off, and the requirement that fights performance. These are the ones I've learned to design for.

Challenge 01

Many scenarios, one consistent UI

The challenge

Every business scenario needed different fields, controls and rules, but the UI and the data structure still had to stay consistent.

How I solved it

I made the UI data-driven: screens render in real time from a JSON structure plus the data. Controls and UI elements are built dynamically for each scenario, so a new scenario is configuration, not a new screen.

Challenge 02

Legacy and new, both live from day one

The challenge

The new platform had to integrate with legacy systems in the current architecture. Both systems had to keep working, with no data lost from day one, and an overnight sync wasn't good enough.

How I solved it

I tracked audit changes and added a hook on every audited data change that syncs the other system. Both systems stay updated in near real time, instead of waiting for an overnight batch.

Challenge 03

Functionality vs performance

The challenge

Functional and business-analyst requirements kept pulling against performance, especially in rare scenarios.

How I solved it

I break requirements into must-haves, good-to-haves and if-possible. I stay in constant touch with stakeholders and the business, and keep improving the logic and architecture so even the rare scenarios perform.

How I approach a new problem

No generic approach.

I don't force one pattern onto every problem because it worked last time.

Every use case earns its architecture.

Different scenarios demand different designs, so I start from the scenario, not the framework.

Modular by design.

A common core holds shared functionality, and dynamic modules carry what varies.

Modular approach

Build the core once. Let scenarios plug in.

Shared rules, data and services live in one tested core. Each scenario adds a dynamic module (UI from JSON, rules as configuration), so the next scenario is cheaper than the last.

From idea to build

  1. Understand the flowWalk the real process end to end before touching code.
  2. Jot it as a diagramPut the flow on paper so everyone sees the same thing.
  3. Review and polishWalk it with the business until it's right.↺ loop until clear
  4. Same for the architectureDiagram it, review it, polish it.↺ same loop
  5. Break it down
    modules›epics›stories›tasks
    plus the testing scenarios for each.
  6. EstimateSize each piece honestly, so we plan on real numbers.
  7. BuildThen build, with the tests already defined.

Working with AI

I don't use AI as autocomplete. I run it like a team.

Codex and Claude Code are part of my daily work, at ISB on a regulated production platform and after hours on my own products. I write the plan, give each agent a lane, and keep the decisions, the real-world testing and the final merge for myself.

1,170Codex threads since Sep 2025
280Claude Code sessions since Sep 2026
757Vive commits co-authored with Claude
5agents with their own lanes on one product

Every month, for over a year

Codex threadsClaude Code sessions
From my local Codex and Claude Code history. Claude Code sessions are counted from September 2026, when I started keeping its history on this machine. November 2026 is partial.

My AI team on Vive

Each agent gets the work it's best at, its own git worktree and branch, and a scratch environment so it can't touch my real setup. Nobody pushes or merges except through the coordinator, and nothing ships without my approval.

Me · OwnerProduct decisions, testing on real projects, the final merge
Coordinator · ClaudeWrites the prompts, checks every agent's report against the repo, then merges and re-verifies
Codex

UI-heavy phases: the canvas, panels and workspaces.

own worktree per phase

Claude, local

Policy, the engine, adapters, code recognisers and polish passes.

own worktree

Claude, cloud

Pure code with deterministic tests: no UI, no local projects.

cloud/<name> branch only

Antigravity

Small, exactly specified jobs: tooling, docs, tests and verification.

tools worktree

How a change moves through the team

  1. PlanThe spec, handover, decision log and open questions go in the repo, so every session starts from the same brief.
  2. SplitOne branch per phase, each with a base commit, the files it owns and a checkpoint to report.
  3. IsolateScratch homes and profiles for every run, and only scratch copies of real projects.
  4. BuildAgents work in parallel and commit locally. They never push, merge or rewrite history.
  5. VerifyCheck the git state and that files stayed in their lane, run build, lint and the full tests, read the riskiest code and probe it.
  6. ApproveI run it on real projects, question skipped tests and measurements, then approve the merge.

What it changed at work

I spend less time typing a first draft and much more on what matters: defining behaviour, comparing approaches, testing the real experience and deciding what's ready to ship.

On ISB Trace I used Codex to trace a single submission end to end: from the API, through each stored JSON payload and the regulatory transformation, down to which database table a setting comes from. I understand complex systems faster, and I can explain them to testers.

What it changed in my life

AI widened what one person can make. On top of enterprise engineering, I now explore animation, voice, storytelling and music: lip-sync workflows, cinematic storyboards, and GenART, a lyric-video studio with Bengali and Hindi transcription.

When a tool slows me down, I build the fix. UsageBar exists because I kept hitting usage limits mid-task, and orbit-board exists because my agents needed a shared board.

How I keep it honest

I ask two agents the same product question and compare their reasoning before I choose. I make critique a separate job: one agent proposes and another challenges it. I ask for a running preview, not a claim, and for performance numbers with the machine, fixture and method recorded.

My vision

Software as a living model people steer. Agents write most of the code. People state intent, watch the system run, and approve changes on evidence. Code on disk stays the truth.
A developer

replays a request across a visual map of the system and follows it into the exact source code.

A business analyst

states a new approval rule in plain words and sees how it changes a real workflow, before anyone writes code.

An architect

compares two proposed implementations side by side against the same traffic.

Everyone

runs AI that's private and fast enough on their own machine to use every day, and that shows its evidence.

How I think

What sixteen years taught me to build for.

These show up as design decisions in the work, not just as slogans.

1

Evidence before approval.

No change lands because a model sounds confident. It lands because you saw it run, saw the diff and saw the tests.

Vive · VOT

2

A finding you can't trust is worse than none.

Six real issues beat fifteen buried in forty inventions. Precision and honesty, including "I'm not sure".

Reviewer · Blobby

3

Local first, private by default.

If it can run on your machine, it should, and your screen and data should stay there.

Blobby · Orbit · AVATARA

4

Code on disk stays the truth.

Canvases and agents are views onto the real system, never a second source of truth that drifts.

Vive V2 → V3 · orbit-board

5

Make rules configuration.

When the world keeps changing (regulation, workflows, schemas), design so the business can change without a redeploy.

ISB Trace rules engine

6

Write the plan, then let agents run.

Specs, decision logs and contracts first, then many agents in parallel worktrees. Clear intent makes agent code reviewable.

Vive · LocalForge

All work · tap any project for its journey

Everything in one place.

Toolkit

What I build with.

Backend & data

C# / .NET CoreREST API designPostgreSQL / JSONBSQL ServerOracleSQLiteApache SolrFastAPI

Platforms & cloud

OutSystemsAWS LambdaEventBridgeECRAzureDockerNginxJenkinsKeycloak / OIDC

Frontend & native

TypeScriptReactNext.jsSwiftUI / AppKitRustTauriElectronCode OSS

AI engineering

MLXOllamaMCP serversClaude CodeCodexopencodeLoRA fine-tuningWhisperLiveKitRAG
Next

The next chapter could be yours.

I'm looking for tech lead and AI engineering roles where real software delivery meets agentic systems. London, hybrid or remote.