Mochi on Jahvon Dockery https://jahvon.dev/tags/mochi/ Recent content in Mochi on Jahvon Dockery Hugo -- 0.148.1 en Wed, 06 May 2026 00:00:00 +0000 AI as a Development Partner https://jahvon.dev/notes/ai-development-partner/ Wed, 06 May 2026 00:00:00 +0000 https://jahvon.dev/notes/ai-development-partner/ Reflections on how I’ve been using AI as a development partner - what I delegate, what I don’t, and what it’s produced. Last fall I wrote about using AI as a creative partner after helping with a HGSE module on vibe coding. The conclusion I landed on was careful: AI works best as a scaffold, not a substitute. Use it consciously, review everything, keep your judgment in the loop. I still believe that. But I’ve spent the last few months testing what that actually looks like when the output has to live somewhere.

Creative work you experience once. Development work you live in. That difference changes what you need from a partner.

The Bench

When I was at Recurse Center last summer, I started integrating AI more intentionally into how I build. Not for speed, for learning. I wanted to experiment with architectures I wouldn’t normally try, undo decisions cheaply, and see what held up. Flow was the natural workbench. It’s my own tool and I know every corner of it.

Over the last few months I’ve been building Flow Desktop and refactoring pieces of the core CLI with AI doing a lot of the implementation work. The experience has been different from vibe coding in ways that matter. In the HGSE projects, I was optimizing for something working. Here, I’m optimizing for something I can read six weeks later, find when I need it, and build on without second-guessing what’s underneath.

That changes what I actually delegate.

The Delegation Model

The architectural decisions stay with me. What the data model looks like, how executables get resolved, where state lives. What I hand off is the implementation of decisions I’ve already made. I describe the shape of what I want, review what comes back against that shape, and merge when it aligns. When it doesn’t, I say so explicitly.

A concrete example: I’ve been building an AI proxy backed by Cloudflare AI Gateway that sits across all of my tools. I decided on the architecture, what the proxy needs to do, how it integrates with the Cloudflare platform, what observability I want. AI implemented it. The Cloudflare MCP server made the feedback loop tight enough that I could test and iterate without switching contexts.

What makes this work is having a single place to see everything. Everything I’ve configured, discoverable from one surface.

Flow v2 Terminal UI

One of the real risks of AI-assisted development is ending up with code you can’t navigate. Outputs that don’t connect to anything, a project that sprawls in ways you can’t audit. The workspace model keeps that from happening. I know where things live because I designed where they live.

I’ve also started using AI to enrich Flow itself, generating executable metadata, adding descriptions and tags, making the library more useful as it grows. Flow has an MCP server, so AI tools can interact with it directly. Watching an AI tool work with Flow rather than just producing files has been one of the more interesting parts of this.

Licklider’s framing from the last post still holds here. Set the goals, determine the criteria, perform the evaluations. That’s still your job. What’s changed is my confidence in what I can hand off once those things are set.

What It Produced

The review and iterate phase is where the real work happens. AI gets you to a first draft faster. Whether that draft is right is still a judgment call only you can make.

A few months of this produced Flow v2 and something I’ve been sitting on: Mochi. Development workflows have a way of becoming invisible. They exist, they’re just not anywhere you can see them. It’s a local-first dev ops dashboard built on Flow. Point it at a directory and it finds your development scripts and automations, turns them into a unified, AI-enriched dashboard. No cloud, no accounts, works with whatever you’re already running.

Mochi Executables View Executables view. Everything Mochi found across my workspaces, tagged and filterable.

Still early. If it sounds useful, the waitlist is at mochiexec.io.

I’m more convinced than I was last fall that the gap worth closing isn’t between what AI can produce and what you can prompt. It’s between what AI produces and what you actually understand. Building in a system you designed is one way to stay honest about that.

]]> Mochi https://jahvon.dev/architecture/mochi/ Mon, 01 Jan 0001 00:00:00 +0000 https://jahvon.dev/architecture/mochi/ Mochi is a local-first DevOps dashboard that auto-discovers your workflows and turns them into a unified, AI-enriched interface. Built on Flow. .notice { --title-color: #fff; --title-background-color: #6be; --content-color: #444; --content-background-color: #e7f2fa; } .notice.info { --title-background-color: #fb7; --content-background-color: #fec; } .notice.tip { --title-background-color: #5a5; --content-background-color: #efe; } .notice.warning { --title-background-color: #c33; --content-background-color: #fee; } @media (prefers-color-scheme:dark) { .notice { --title-color: #fff; --title-background-color: #069; --content-color: #ddd; --content-background-color: #023; } .notice.info { --title-background-color: #a50; --content-background-color: #420; } .notice.tip { --title-background-color: #363; --content-background-color: #121; } .notice.warning { --title-background-color: #800; --content-background-color: #400; } } body.dark .notice { --title-color: #fff; --title-background-color: #069; --content-color: #ddd; --content-background-color: #023; } body.dark .notice.info { --title-background-color: #a50; --content-background-color: #420; } body.dark .notice.tip { --title-background-color: #363; --content-background-color: #121; } body.dark .notice.warning { --title-background-color: #800; --content-background-color: #400; } .notice { padding: 18px; line-height: 24px; margin-bottom: 24px; border-radius: 4px; color: var(--content-color); background: var(--content-background-color); } .notice p:last-child { margin-bottom: 0 } .notice-title { margin: -18px -18px 12px; padding: 4px 18px; border-radius: 4px 4px 0 0; font-weight: 700; color: var(--title-color); background: var(--title-background-color); } .icon-notice { display: inline-flex; align-self: center; margin-right: 8px; } .icon-notice img, .icon-notice svg { height: 1em; width: 1em; fill: currentColor; } .icon-notice img, .icon-notice.baseline svg { top: .125em; position: relative; }

Note

Mochi is in early access. Join the waitlist at mochiexec.io.

Mochi is a local-first DevOps dashboard built on top of Flow. Point it at a directory and it finds your development workflows and turns them into a unified, AI-enriched interface.

Design Philosophy

  • Local-first: No cloud sync, no external accounts required. Your workflows never leave your machine.
  • Built on Flow: Mochi inherits Flow’s execution engine, secret management, and composability model rather than building a parallel system from scratch.
  • AI-enriched, not AI-dependent: AI augments the experience with workflow analysis and suggestions, but the tool works without it.
  • Unified discovery: Meet developers where they are instead of requiring migration to a new workflow format.

System Overview

Mochi wraps Flow’s CLI engine as its execution runtime. The desktop app and CLI share the same binary, with the desktop communicating through process execution in the same pattern as Flow’s architecture. Discovery runs at startup and on sync, after which all discovered executables are available in both the dashboard and CLI identically.

The desktop is not yet released, but the architecture is taking shape. Here’s a preview:

Auto-Discovery Engine

Mochi’s discovery layer imports executables from common developer workflow files without requiring any configuration changes.

Discovered executables are treated identically to native Flow executables once imported: they appear in the browse interface, support the same reference patterns, and can be composed into larger workflows. The sync step surfaces naming conflicts clearly so nothing is silently overwritten.

This discovery system is built on the same import infrastructure in Flow’s core. See the Flow architecture for implementation details.

AI Enrichment Layer

Mochi connects to an AI provider for workflow analysis, troubleshooting suggestions, and workflow context. You can use Anthropic’s cloud API or a local Ollama instance depending on your preference and privacy requirements.

The enrichment layer is optional and additive. The dashboard is fully functional without it, and workflow definitions are processed locally before anything is sent externally.

Desktop and CLI Architecture

Mochi ships as a single binary that includes both the CLI and the Tauri desktop backend. I chose Tauri because it was the most interesting option at the time, given my interest in learning Rust and building a desktop app without the overhead of Electron. The frontend is TypeScript/React with Mantine UI.

Type safety across Go, TypeScript, and Rust is maintained through code generation from a shared JSON schema. Schema changes propagate to all three languages automatically during the build, and the same schema generates documentation as a side effect. This has been one of the best quality-of-life decisions in the project — make a change in one place and have confidence everything stays consistent.

Docs and Code Generation

Resources

]]>