Core Philosophy: Software should be easy to use, stress-free, and a gentle place to collect your data. It should never feel like a high-pressure chore or make you feel bad when you take a break.
- Keep Details Simple: Do not force users to enter extra details (like exact times or narrow categories) unless the app absolutely needs them to work.
- No Guilt or Punishments: Get rid of high-pressure tracking like daily streak counters. Celebrate when users open the app, but never make them feel bad when they take a break.
- Forgive Mistakes Easily: Expect that first entries will be messy, late, or incomplete. Make it incredibly easy for users to go back and fix or fill in old data later.
- No Scarcity Threats: Never scare or pressure users with bad consequences. Avoid automatic file deletion, expiration timers, or cleanup rules when items are ignored. Let data rest calmly.
- Simple Inboxes, Smart Backgrounds: Give the user a single, clean box to quickly dump their thoughts. Let background automation do the heavy work of sorting and organizing behind the scenes.
- The Idea: Forcing people to pick exact times, locations, or tiny categories creates too much decision fatigue. It makes you feel like you are failing if you do not know all the answers right away.
- The Rule: Never ask for a detailed piece of information unless the app cannot function without it.
- Example: If knowing the general day is enough for a record, hide the exact hours and minutes. If a broad bucket like "Work" or "Play" does the job, do not force the user to create a million tiny tags. Let the system accept broad, fuzzy inputs comfortably.
- The Idea: Many modern apps weaponize daily counts, badges, and red warning alerts. This ends up punishing users just for living their real, busy lives.
- The Rule: Design dashboards to be calm spaces. Taking a break from the app should feel like a normal resting phase, not a graveyard of broken promises.
- Example: Get rid of stressful streak counters and flashing "overdue" warnings. Replace them with quiet grids that light up when you do use them, or flowing views that simply expand when new items are added, keeping the empty days visually neutral.
- The Idea: If an app requires you to be perfect from the very first tap, you will eventually get stressed and quit using it entirely. Human memory and daily habits are naturally messy.
- The Rule: Expect data entries to be incomplete, late, or out of order. Fixing old records or adding missing items later should be just as easy as making a new entry.
- Example: Allow users to quickly slide or drag data around to reorganize it later. Use smart text recognition so a user can just type "Forgot to add this on Monday", and the system fixes the history automatically without forcing them to fight tricky calendar menus.
- The Idea: An app should never feel like a ticking time bomb. Threatening users with "clean up" timers or automatic deletions undercuts trust and creates unnecessary anxiety. Software must never suggest you are "falling behind."
- The Rule: Avoid automatic pruning policies or forced data destruction for untouched elements. If a user chooses to leave data unaddressed, let it exist safely without penalty.
- Example: If you ignore an item or an alert queue, do not let the app automatically throw it away. Let those elements settle quietly into permanent storage contexts where they were born. They will wait securely for you to return to them on your own terms.
- The Idea: Powerful apps should not look scary. Users should not have to face a wall of dropdowns, forms, or settings boxes just to save a basic piece of information.
- The Rule: Give the user a single, friction-free place to capture data. Let smart background systems handle the hard work of sorting, connecting, and filing everything.
- Example: Offer an empty scratchpad or a single text box where you can dump raw, messy thoughts. Behind the scenes, smart background workers read the mess, sort it into clean profiles, and build rich cards for you. If the system makes a mistake, you can easily tap the card, fix the error, and tell the system to try reading it again.