I fix the parts of AI products that fall apart when real users hit them.

• You're building an AI product or SaaS app that's close to launch but still fragile in the critical path.
• Your app is 60 to 90 percent done.
• The UI looks finished, but the core flow still breaks.
• Auth, billing, onboarding, uploads, or AI responses feel unreliable.
• Your product works in a demo, but you would not trust it with real users yet.
• You need a technical cleanup before launch, investor demos, or first customers.

• The app works in a demo, but nobody trusts it for launch.
• Signup, billing, or onboarding still feel fragile.
• Investor demos are fine. First users are a risk.
• The product was built fast and now needs judgment, not more chaos.
• The AI feature technically works, but the failure states are ugly.

• Broken auth and session issues.
• Onboarding and first-user flow gaps.
• Stripe and billing blockers.
• Flaky Supabase behavior, schema, RLS, storage, or edge cases.
• Upload, file, and background job failures.
• Brittle AI flows, bad failure states, and weak guardrails.
• UI states that break trust: loading, errors, retries, and empty states.
• Messy AI-generated code in the critical path.

• I care about the point where the product stops feeling trustworthy: expired sessions, duplicate webhooks, stuck uploads, slow jobs, and AI output that sounds right but is wrong.
• If something fails, the user should know what happened and what to do next. Silent breakage is worse.
• The risky path has to be readable enough that another engineer can debug it without archaeology, especially if AI-generated code touched it.
• I care more about the path that makes or loses money than a long cleanup list.

I start where launch risk is highest, not where the code is most annoying. That usually means the money path, the first-user path, or the AI path that looks fine until a real edge case hits it. I fix the important failures first and leave the low-value cleanup for later.

• One focused sprint on the blockers most likely to hurt launch.
• Fixes shipped to your repo, not a list of suggestions.
• A stronger core path with fewer obvious ways to break trust.
• A short handoff with what I fixed, what I would watch next, and what can wait.
• A Loom walkthrough, PRs or commits, and a prioritized bug list if the project needs it.

• A full rebuild.
• A long-term CTO engagement.
• Endless bug fixing.
• Feature work added as 'while you're in there' cleanup.
• A vague audit with no implementation.