Kill the Mammoth

The task manager that punishes you for waiting.

Comment

Inspiration

Every productivity app I have ever used had the same fatal flaw. Nothing happened if I ignored it.

I could let a task sit for three weeks. The app would wait patiently. No consequences. No pressure. Just an ever-growing list of things I told myself I would do someday.

Real urgency does not work that way. A mammoth in the path of a prehistoric hunter did not wait. You hunted it or you went hungry. The stakes were real and the timeline was not negotiable.

Kill the Mammoth is built on one idea: tasks should have teeth. Miss the deadline and something actually happens. The score drops. The lockout triggers. The app stops letting you add more until you reckon with what you already failed.

What it does

Kill the Mammoth is a task management application where every task is a Mammoth with a countdown timer. You hunt it by completing it before the timer runs out. Let it expire and it rots — taking points with it.

The scoring system is simple and unforgiving:

$$S_{survival} = S_{initial} + \sum_{i=1}^{n} C_i - \sum_{j=1}^{m} 2E_j$$

where $C_i = +1$ for each completed task and $E_j = +1$ for each expired task. The asymmetry is intentional — expiry costs twice what completion earns.

When the Survival Score drops below zero the lockout triggers. Task creation is disabled for one hour. The app displays an LLM-generated critique built from the specific tasks you let rot. Not a generic message. A sentence written about your actual failures.

Beyond the core mechanic the app includes voice input for task creation using the browser Web Speech API, category and priority organization, a full Analytics Dashboard with completion rate charts, a public leaderboard ranked by Survival Score with privacy controls, Google Calendar integration, and ICS file export for any calendar application.

How we built it

Built entirely using MeDo through conversational prompting in four turns.

Turn 1 built the authentication system, the core database schema across four tables (Hunters, Mammoths, Completed, Rotten), and the main dashboard with the Survival Score display and active task view.

Turn 2 implemented the task expiration engine — the continuous monitoring system that detects when countdown timers reach zero, moves records from Mammoths to Rotten, deducts points, and triggers the lockout mechanism with LLM critique generation.

Turn 3 added the full feature layer: voice input via Web Speech API, category management, priority levels, the Undo system with the 5-second window, the notification system, dark mode with persistent preference storage, and the Task Edit Modal.

Turn 4 built the Analytics Dashboard with historical charts, the Leaderboard with privacy controls, the Settings page, Google Calendar URL generation, and ICS file export.

Total build time: approximately 3 hours.

Challenges we ran into

The expiration engine required strict server-side enforcement. Client-side timers can be paused, manipulated, or simply stop running when a tab is backgrounded. The expiration timestamp needed to be calculated at creation and checked server-side continuously — not trusted to a JavaScript countdown. Getting MeDo to implement the expiration as a server process rather than a frontend timer took one full prompt iteration.

The LLM critique had to feel personal, not generic. Early versions produced lines like "You need to manage your time better." Useless. The fix was passing the actual expired task descriptions as context so the critique referenced what specifically was abandoned. "You let 'prepare for tomorrow's presentation' rot. That was not a mammoth. That was a choice."

The Undo system needed precise state management. A 5-second window that reverses a database write while keeping the UI consistent required careful sequencing. The task needed to be moved back from Completed to Mammoths, the score needed to be decremented, and the countdown needed to resume from where it was — not reset to the original duration.

Simultaneous expirations stressed the scoring logic. If three tasks expire at the same moment, the system must process each deduction sequentially without race conditions. MeDo's implementation needed explicit sequential processing rather than parallel writes to avoid scoring errors.

Accomplishments that we're proud of

The lockout mechanic with LLM critique is the feature we are most proud of. Every other task manager treats failure as a neutral event. Kill the Mammoth treats it as information and delivers that information directly. The critique is not punishment — it is a mirror. Seeing a specific sentence about the specific tasks you abandoned is more motivating than any streak counter.

The scoring asymmetry is the design decision we are most proud of. The $-2$ for expiry versus $+1$ for completion is not arbitrary. It reflects the actual cost ratio of procrastination. One task avoided requires two tasks completed just to break even. That math changes behavior.

$$\text{Break-even ratio} = \frac{|E_{penalty}|}{C_{reward}} = \frac{2}{1} = 2$$

You must complete two mammoths to recover from letting one rot.

What we learned

Consequences are features. Every productivity tool tries to make tasks easier to complete. Kill the Mammoth makes failure harder to ignore. The lockout is not a punishment system — it is a feedback loop. The app stops working until you acknowledge what happened.

Asymmetric scoring changes psychology. Equal penalties and rewards produce neutral behavior. When the cost of failure is twice the value of success, the mental calculus shifts. Players reported that the $-2$ felt unfair at first and then became the reason they actually completed tasks.

Voice input removes the friction that kills consistency. The most common reason task managers fail is that creating a task takes more effort than just doing the thing. The microphone button reduces task creation to a spoken sentence. That friction reduction matters more than any feature.

What's next for Kill the Mammoth

  • Recurring mammoths for habits and routines that need regular hunting
  • Squad hunts where teams share a Survival Score and face collective consequences for individual failures
  • Difficulty tiers with adjustable penalty ratios for players who want harder or softer consequences
  • Weekly hunt report delivered by email showing total mammoths killed, total rotted, and one LLM-generated observation about the pattern
  • Mobile app with push notifications so the mammoth can find you, not just wait for you to open a browser

Built With

Share this project:

Updates