Ben's Builds #3 - an email app

DeepTrendLab's Take on Ben's Builds #3 - an email app

A developer using Claude Codex and Factory built a custom email client optimized entirely for his workflow, replacing Superhuman with a locally-run application that syncs with Gmail. The app combines split inboxes, rule-based filtering, keyboard shortcuts, a command palette, compose and reply functionality, undo-send with a 20-second window, one-click unsubscribe, search, and rules that sync bidirectionally with Gmail's label system. The application was built iteratively, moving from Codex for initial implementation to Factory for UX refinement, with ongoing optimization driven by agent-identified performance bottlenecks. This is not a proof-of-concept—it's a production tool for daily use that consolidated multiple features the developer actually wanted into a single interface.

The motivating insight was straightforward: a premium email client like Superhuman solved the keyboard-first, clean UX problem, but it justified its cost through feature bloat that didn't align with his actual needs. His email organization relies on a handful of existing labels—investing, FYI, calendar, news, and pitch—that map cleanly to filtering and rules rather than requiring intelligent categorization. The trigger to build rather than pay was the mismatch between what he valued (speed, personalization, cost efficiency) and what the product was optimizing for (feature completeness and enterprise adoption). This framing inverts the traditional SaaS playbook: instead of buying a general tool and configuring it, he extracted the minimal viable set of features he needed and built around that constraint.

What stands out is not the technical achievement but what it reveals about AI agent maturity in real-world development workflows. The performance debugging illustrates this shift: the agent identified that excessive Gmail API polling was creating latency, then drove the architectural evolution toward cached-first UX with background refresh and optimistic updates. The move from client-side rules to Gmail-synced filters required the agent to surface a conceptual error—defaulting to local state instead of source-of-truth synchronization—that a human might rationalize away. The subsequent layer of complexity, making rules conditionally apply to specific domains or all addresses within a label, emerged from iterative use rather than upfront specification. This iterative refinement loop, with an agent driving UX and architectural decisions, suggests agents are moving beyond code completion into design partnership territory.

The immediate impact ripples through the vertical SaaS market. Tools like Superhuman occupy a premium niche by bundling UI polish with platform-specific optimization—but they're defending against a new form of competitive pressure where the alternative to buying is building with AI assistance, at roughly the cost of a single month's subscription versus annual commitment. For developers with defined workflows and clear requirements, the economics now favor customization over adoption. This extends beyond email: any vertical SaaS with a clear core use case and a limited feature set becomes vulnerable to teams that can articulate their needs precisely and let agents translate that into implementation. The developer's observation that he didn't need AI to categorize every email—just smarter filtering—points to a broader insight: AI agents are more valuable as development accelerators than as replacement decision-makers in consumer-facing tools.

Against Superhuman and Gmail's native rules, this custom approach offers something different: a genuinely optimized interface for one person's actual workflow, without compromises for feature parity or extensibility. Superhuman's strength is its polish and speed for general keyboard-driven email use; the custom build's strength is laser focus and bidirectional Gmail sync. Neither would work for a team, but for individual power users, the calculus shifts. The competitive landscape is now three-sided: traditional desktop clients (slowly declining), premium managed solutions like Superhuman, and increasingly, agent-assisted custom builds. Superhuman stays viable for users who value signal filtering without wanting to build, but the cost structure and feature treadmill create obvious tension with developer-builders who can now encode their preferences in code.

The open questions are about durability and leverage. Will custom agent-built tools prove maintainable as codebases grow? Can this model scale to tools requiring team coordination or external integrations beyond Gmail? The deeper implication is that we're watching the emergence of a post-platform dynamic: instead of platforming software through distribution and enterprise sales, capability is increasingly platforming through agents, which compress the friction between "I need something" and "I have something that works." Whether the pattern holds depends on whether agent-assisted development stays iterative and exploratory—discovering requirements through building—or becomes predominantly about executing known specs. Based on this example, the agents are adding value precisely where they stay in the loop, identifying performance problems and architectural mismatches that specs wouldn't have caught.