MRM.

AI-native builder · works project by project · moves fast

I build fast —
and I know
when the AI is wrong.

Landing page one day, an automation the next, an internal tool after that. I ship in days, not weeks. The difference is that every build leaves my hands with a net under it — audits, smoke tests, and an auditable trace — so it survives real use instead of quietly rotting in week two.

Point me at your scoped project → See how I handle the last 20%
Daysnot weeks
Provableevery change, traced
Ownernot hours-counter
The actual skill

Anyone can generate a prototype now. Knowing when it's wrong is the job.

Fast, on purpose

I live in Claude Code and Cursor and have real opinions about them. I build in days what used to take weeks — and I pick the right stack for the job, not the one platform I happen to know.

Provable, always

Every change runs through audits and smoke tests before it ships, with an auditable trace of exactly what changed and why. Nothing goes backwards without a test screaming first.

I know where it breaks

Generating output is easy; catching the insecure, the wrong, the won't-survive-production is the value. I find it before your users do — because I assume the AI is confidently mistaken until proven otherwise.

Selected work

Shipped things people use — and maintained past launch.

01Modernization · Rust

Legacy system → modern Rust, proven byte-exact

Rebuilt a decades-old system on a modern stack and proved the new output matched the original byte-for-byte with an automated parity harness. When the AI reported “100% done,” my harness showed 752 of 763. I shipped the honest number with a full trace, then closed the gap deliberately — instead of letting anyone discover it in production.

  • Parity harness
  • Honest reporting
  • Zero silent regressions
02Product · SaaS

Multi-tenant enterprise platform, bilingual

A full enterprise SaaS on a clean architecture — .NET on the back, React/TypeScript on the front, fully bilingual English/Arabic with proper right-to-left support. Shipped with 341 passing tests and a zero-warning build, hardened so a demo config can never leak into production.

  • .NET · React/TS
  • EN / AR · RTL
  • 341 tests green
03Automation · Tooling

One-command data scrubber

Built a tool that auto-detects the format of any messy data dump — CSV, SQL, JSON, legacy fixed-width — and strips the sensitive values while preserving the exact layout and edge cases, so downstream tests still pass. A manual, error-prone half-day became a single command, and real-shaped data became safe to share.

  • Format auto-detect
  • Byte-layout preserving
  • Reversible
04Framework · Delivery

The regression-proof delivery framework

The through-line behind all of it: a way of shipping fast without shipping fragile. Every build carries its own audits and smoke tests, and every change writes an auditable trace. If something would break, it fails loud and halts — never a silent corruption you find weeks later.

  • Audits + smoke tests
  • Auditable traces
  • Fail-loud, not silent
The last 20%
“AI gets me to 80% in an afternoon — scaffolding, layout, first-pass logic. The last 20% is where the money is, and it's the part most people skip. I don't trust generated output until it's proven. That's the whole job: fast, and provable.”
1

Assess. Understand what actually needs to exist and where it can bite.

2

Build. Move fast with AI for the 80% — components, flows, first-pass logic.

3

Prove. Audits + smoke tests on every change, with a trace of what moved and why.

4

Ship & maintain. Hand over something that survives real use — and keep it alive.

Have something scoped?
Let's build it.

Website, app, membership portal, or an automation that saves your team hours — I pick the right tools and execute. I'd rather solve it than pad it.

Start a project →