I disabled push notifications on my own AI productivity app within 24 hours of shipping it.

That was the moment I realized I had built something that looked useful but was actually attention spam dressed up in a clean UI.

Here's what was wrong, what I learned, and the architecture I rebuilt around it.

The "helpful" trap

The first version of my product (then called EVE, now Jigeum) did the obvious thing: connect Gmail, classify emails, surface anything important via push notification.

The logic seemed sound. The execution was a disaster.

Day 1, 9am: push notification — "Stripe receipt may need attention"
Day 1, 9:14am: push — "LinkedIn message from a recruiter"
Day 1, 9:32am: push — "GitHub PR review request"
Day 1, 10:01am: push — "Newsletter — possibly important"

By noon I had 14 notifications. By 5pm I had silenced the app on my phone.

I had recreated the exact problem I was trying to solve: another channel demanding my attention, no smarter than the inbox it was sitting on top of.

The wrong mental model

Here's the assumption almost every AI productivity tool makes — and the one I had to unlearn:

"If something is important, notify the user. If it's not, don't."

This is wrong. Importance is binary. Attention is not.

The real model is: every signal has an escalation level, and most signals deserve none.

A contract waiting for signature is not the same as a newsletter from a YC partner you respect. Both are "important." Only one should interrupt your morning.

The architecture I rebuilt: 5-tier escalation

Every incoming signal — email, calendar event, extracted commitment — gets classified into exactly one tier:

SILENT    → never surfaced
QUEUE     → added to a review list, no notification
PUSH      → mobile push, the actual interrupt
CALL      → urgent override (not yet built)
AUTO      → handled without asking me

The default is QUEUE. Not PUSH. Most things just sit there until I open the app.

This single change — defaulting to the quietest reasonable tier instead of the noisiest — is the difference between a tool I use and a tool I muted.

Trust Score: who actually deserves to reach you

Routing depends on the sender. Each contact has a Trust Score (0–100) derived from real interaction history:

interface TrustScore {
  userId: string;
  contactEmail: string;
  score: number;               // 0–100
  interactionCount: number;
  avgResponseMinutes: number | null;
  lastInteractionAt: Date | null;
}

A cold sender I've never replied to: ~10.
A teammate I exchange messages with daily: ~95.

Tier assignment combines Trust Score × content urgency × time-of-day context. A 95 score sending a question gets PUSH. A 10 score sending the same question gets QUEUE. Same email content, different outcome — because who matters as much as what.

Commitment Ledger: the feature I didn't know I needed

This was the unexpected one.

Every email where I had written "I'll send the contract by Friday" or "Let me get back to you next week" — those were commitments I kept forgetting. They lived inside threads. The other person remembered. I didn't.

interface Commitment {
  id: string;
  userId: string;
  title: string;
  kind: "DELIVERABLE" | "MEETING" | "FOLLOW_UP" | "DECISION";
  owner: "USER" | "COUNTERPART";  // who owes whom
  dueAt: Date | null;
  dueText: string | null;          // "by Friday", "next week"
  confidence: number;              // 0–1
  status: "OPEN" | "DONE" | "OVERDUE";
}

The confidence score matters. "Let's sync sometime" → 0.3, ignored. "Please send the NDA by Tuesday EOD" → 0.9, surfaced immediately.

In four weeks of dogfooding, this caught three commitments I would have genuinely dropped. That's the metric I judge the whole product by now.

What changed when I rebuilt around this

The Command Center is one page with four blocks: Morning Briefing, Approval Queue, Commitment Ledger, Reply Needed. I open it once before email and I'm done.

I haven't opened raw Gmail first thing in the morning in 3 weeks.

The principle

If I had to compress the lesson into one rule it would be this:

Default to silence. Earn the right to interrupt.

Most "smart" tools fail because they assume the user wants to be helped at every opportunity. The user does not. The user wants their attention managed down, not flooded with more "important" inputs.

Stack

For the curious:

• API: Fastify + TypeScript + Prisma + PostgreSQL (Supabase)
• Web: Next.js 15 App Router
• AI: Claude Sonnet for content analysis, Claude Haiku for classification
• Email: Gmail API with incremental sync
• Push: Web Push API + service workers
• Deploy: Render (API) + Vercel (web)

Try it

Jigeum is in private beta. Connect Gmail + Calendar, initial sync takes about 30 seconds, and you'll see your inbox classified by tier within a minute.

If you're a founder, solo operator, or anyone whose inbox is currently managing them — I'd genuinely value the feedback. Especially where the classification gets it wrong. That's where the next iteration comes from.

Architecture questions welcome in the comments.

Built solo. The first version annoyed me. The second one I actually use.