Skip to content
Let's talk

AI has to earn its place in the product.

Show it where it builds trust. Hide it where it saves time. That call is mine, not the model's. At Axios HQ I led the AI strategy that doubled platform usage. At Salesforce I shipped some of the first Einstein experiences. Today it runs in production across Nibbble, Simple Cortex, and Kintsu Medspa. Most AI features do not earn their place. The ones below did.

In production

  • Axios HQ

    2×

    AI usage across the platform. Sr. Director of Product and Design, 2023 to 2025.

  • Nibbble autofix

    17

    Real production fixes shipped by an AI assistant working unattended on a small, fenced-off list of files. The local model runs free per attempt.

  • Nibbble repo

    412

    Code commits to the live product in twelve weeks. Mohsin wrote most of them. Claude paired on nearly half.

  • Nibbble coverage

    95.75%

    Automated tests cover almost every line of a live SaaS product serving multiple restaurants. 21 architecture decisions are written down in the repo.

  • Kintsu brand system

    2,745

    Lines of brand strategy I wrote and made AI-enforceable, across six long-form documents AI agents read on every session.

Where it shows up in the work

  • Axios HQ

    Re-architected the product in 90 days and doubled AI usage across the platform. Sr. Director of Product and Design.

    Read the case study →

  • Nibbble.io

    A loyalty product serving multiple restaurants, live since April 2026. Code my AI assistant wrote, reviewed, and committed while I slept: 17 real fixes in production, each scoped to a small list of files I pre-approved. The codebase is mapped into a 3,339-node knowledge graph the assistants check before they search, so they understand the system before they touch it.

    Read the case study →

  • Simple Cortex

    Three AI agents that run a consulting practice. Each agent's job description, instructions, runtime behavior, and tools live in their own file in a repo, so anyone can review what an agent is supposed to do separately from how it does it.

    Read the case study →

  • Kintsu Medspa

    Brand voice written as enforceable rules every AI reads before it writes a single line of copy. Prohibited words, voice pillars, motion rules, and compliance constraints all live in AI_DESIGN_GUIDELINES.md. Voice survives at the contract stage, not at review.

    Read the case study →

  • Deep-researcher skill

    A custom research assistant I built. Takes a brief, goes off and researches, returns sourced findings. Modeled on Manus.im and built on top of Hermes, the open-source agent from Nous Research. Plan, Act, Observe, Update, with citation tracking and local-first model routing. It produced the Kintsu marketing playbook, the SEO and AEO audit, and an HRT business-intelligence report under brief.

    Operator note

Not aspirations. The rules my repos and my teams run on today.

How I work with AI

  1. Visible where it earns trust. Invisible where it earns time.

    AI shows up in the interface when seeing it helps the user. It stays out of the way when it is just a faster path to the same answer. That call is the same on every product surface, and it is mine, not a model's.

  2. Local-first routing. Cloud where judgment matters.

    Most AI tasks are cheap and bounded. Those run on free, local models. The hard, irreversible calls (architecture, judgment about user trust) go to Claude in the cloud. Cost shows up where the decisions get made.

  3. Voice and brand as contracts the AI reads every session.

    Brand voice, prohibited words, motion rules, color tokens, and compliance rules live as files in the repo. Every AI agent reads them before it writes. Drift gets caught at the contract stage, not at review.

  4. Cost and provider health are operating surfaces, not slides.

    I can check what every AI call cost me today the same way I check the weather. One command at the terminal. Provider health and per-route spend are everyday operator surfaces, not a quarterly review item.

  5. Agents review agents.

    One AI proposes the work. Another AI reviews it before it ships. Codex blocks pull requests on the Nibbble repo if the change misses the bar. Humans merge. The AI accountability ladder is not optional.

What stays out of the work

  1. AI demo theater.

    No future-of-design essays. No speculative roadmaps. No logo grids of model providers standing in for capability.

  2. AI features without a fallback.

    Every AI surface ships with an explicit handoff to a human and an editable output.

  3. Speed paid for by dropping the bar.

    Cycle time and quality get measured side by side. AI shortens the path. It does not move the destination.

  4. Final calls delegated to models.

    Product direction, user trust, hiring, team direction. Those stay with humans.

How I tune my tools

  1. I coordinate. Cheaper models execute.

    My global Claude Code rules make the main session a coordinator. It designs, reviews, and decides, then hands execution to Sonnet or Haiku subagents. Concurrency is capped at three, and non-trivial changes get a reviewer with a fresh context. The goal is top-model judgment without top-model token burn.

  2. Typed judges instead of chat.

    Two decision models answer bounded yes/no and pick-one questions instead of writing prose. Jev, from TypeSafe, is a hosted System One model. Clef Flash, from Cloudflare Workers AI, I also run locally through Ollama.

  3. Jev scores my essays against my own writing.

    It checks each essay, section by section, against my published writing, to catch drift toward generic AI prose before I publish. It is advisory, not a deploy gate.

  4. Three Claude Code mods I built.

    compact-memory decides which tool output survives context compaction, using local Clef Flash with Jev as a fallback, so long sessions keep the paths and errors that matter. browser-fast-step lets a small typed model pick routine browser actions and escalates anything risky. qwen-driver hands bounded coding tasks to Qwen in an isolated worktree and never merges or pushes.

  5. Hooks do the bookkeeping.

    A SessionEnd hook writes my devlog. A code-graph gate routes searches to a codebase index before grep.

One brain. Many models. Cost on every call.

Agents ask for a capability, not a model by name. A router picks the right model, falls back if it has to, and tracks what the call cost. Local models handle the cheap, bounded work. Cloud models handle the judgment calls.

Layer 01 · Surfaces

Where the work happens. Each surface reads the same repo-level contracts.

  • Claude Code
    Primary engineering pair
  • Codex CLI
    PR review gate
  • Warp
    Agentic terminal
  • Conductor
    Parallel CC sessions in tabs
  • Perplexity
    Live research surface
  • Manus.im
    Autonomous research and writing service
  • Claude Agent SDK
    Programmatic agents

Layer 02 · Routers

Agents call by intent. Routers classify, fall back, and meter cost.

  • OpenClaw Router
    Classify · architect · engineer · analyst · triage
  • Hermes
    Semantic router across skills and providers
  • Custom routers
    Per-project intent-to-model mapping

Layer 03 · Providers

Cloud where judgment matters. Local and hosted open source for bounded structure.

  • AnthropicCloud
    Cloud judgment
  • OpenAICloud
    Codex review
  • Alibaba CloudCloud
    Coder plan, Kimi access
  • OllamaLocal
    Local runtime
  • FireworksHosted OSS
    Hosted OSS inference

Layer 04 · Models

Named, not aspirational. The exact models the agents resolve to today.

  • claude-fable-5-1Cloud
  • claude-opus-5-5Cloud
  • claude-sonnet-5-5Cloud
  • gpt-6-lunaCloud
  • kimi-k2-6Cloud
  • qwen3.8:27b-mlxLocal
  • qwen3.6:27bLocal
  • qwen3-coder-next:q4_k_mLocal
  • openclaw-qwen35-a3b-thinkLocal
  • qwen3.5:9bLocal
  • llama3.2:3bLocal

What runs unattended

An overnight job on the free local tier tunes routing and prompts on its own. Thirty dated research branches over two months. The cheap tier earns its keep.

Hiring a design leader who actually ships AI?

See the workHire me →