I build production-ready software solo, using VS Code and an AI-assisted development (Claude Code) as a core part of my workflow — not to skip understanding the code, but to move faster through a disciplined, iterative process: scaffold, implement, test, debug, repeat.

**How I work**
- **Step-by-step, not one-shot.** I break projects into phases (Phase 0, Phase 1, Phase 2...) with clear scope per phase, rather than asking for a finished app in one go.
- **Test-driven troubleshooting.** I actually run and click through what gets built — deploying to real environments (Netlify, Supabase) early and often — rather than trusting code in the abstract. When something breaks, I trace it to root cause instead of patching symptoms (e.g., untangling five interconnected bugs across env in lining, race conditions, token parsing, middleware, and cookie handling in a single auth flow).
- **Architecture-first decisions.** Before heavy implementation, I lock in key structural choices — routing strategy, auth model, single-codebase vs. multi-tenant, pricing tiers — so later phases build on solid ground instead of getting rebuilt.
- **Consistent, opinionated stack.** Vanilla JS + IndexedDB + Service Workers for offline-first PWAs (POS, Pet Shop). Next.js 14 + Supabase + Netlify for multi-tenant SaaS platforms (Parish CMS). I reuse proven architecture across projects rather than reinventing it each time.
- **Business-aware development.** I don't just ship features — I validate them against real market fit (Philippine/SEA pricing tiers, feasibility analysis, licensing strategy) before scaling scope.

**What I've built**
- **Parish CMS** — multi-tenant SaaS for Catholic parishes (Next.js 14, Supabase, subdomain + custom domain routing, admin auth with bcrypt + signed cookies)
- **POS System** — offline-first point-of-sale PWA with RBAC, shift/drawer session tracking, inventory, and reporting, now scoping toward cloud sync and licensing
- **Pet Shop PWA** — appointment and records management app extending the POS architecture
- **VA Platform concept** — exploring a managed/curated virtual assistant service model as a separate business line

I'm a solo builder who ships real, tested, deployed products — not demos — by pairing hands-on QA discipline with AI-accelerated implementation.
There's a common worry with AI-assisted development: that "vibe coding" means shipping whatever the AI generates first, untested, and hoping it holds up. That's not how I work. I use AI (Claude Code) the way a skilled contractor uses power tools — it speeds up the build, but I'm still the one on-site checking the wiring, testing the load, and signing off before anyone moves in. Every feature goes through the same discipline regardless of how it was written:

Nothing ships untested - Every phase gets deployed to a real environment and actually used — clicked through, logged into, stress-tested — before I call it done. My POS system's auth flow, for example, went through real-world debugging across five interconnected failure points (environment config, race conditions, token handling, middleware, cookie state) until it was airtight, not just "looks right."

Architecture decisions are mine, not the AI's - Before any code gets written, I decide the routing strategy, data model, auth approach, and tenancy structure. AI implements against a plan I've already validated — it doesn't set the direction.

I understand every system I ship - If something breaks in production, I can trace it, explain it, and fix it — because I built it phase by phase and verified each layer, rather than accepting a black box.

Consistency over novelty - I reuse proven, battle-tested architecture (the same offline-first PWA pattern across POS and Pet Shop, the same Next.js/Supabase foundation across SaaS projects) instead of letting AI improvise a new stack each time. Familiar foundations mean fewer surprises for clients.

AI is a speed multiplier, not a shortcut - It lets me deliver multi-phase, production-grade software as a solo developer at a pace that would normally require a small team — without cutting the QA and architecture steps that make software trustworthy.