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.
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
Understand the flowWalk the real process end to end before touching code.
Jot it as a diagramPut the flow on paper so everyone sees the same thing.
Review and polishWalk it with the business until it's right.↺ loop until clear
Same for the architectureDiagram it, review it, polish it.↺ same loop
Break it down
modules›epics›stories›tasks
plus the testing scenarios for each.
EstimateSize each piece honestly, so we plan on real numbers.
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
PlanThe spec, handover, decision log and open questions go in the repo, so every session starts from the same brief.
SplitOne branch per phase, each with a base commit, the files it owns and a checkpoint to report.
IsolateScratch homes and profiles for every run, and only scratch copies of real projects.
BuildAgents work in parallel and commit locally. They never push, merge or rewrite history.
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.
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