Should I vibe code
Combine calendar, tasks, notes, and a command palette into one personal workspace
A planner you don't fully trust is worse than no planner, and trust lives in the sync layer, not the UI.
?
Their verdict, the Professional price and the build-time estimate come from their entry, MIT-licensed. Checked 2026-08-04.
?
Our verdict, the regret score and everything below it. Editorial and unsponsored — nobody can pay to be moved.
The honest answer
why the verdict is what it is
One sitting gets you the part that feels like the product: a command palette, a today column with your calendar down one side, and tasks you can drag onto a free half-hour. It is a genuinely lovely afternoon. The product is the other ninety percent — a note store you trust with the only copy of a thought, a mobile client for when the idea arrives on a train, offline edits that merge rather than clobber, and two-way sync with Google Calendar, Todoist and Notion, each of which believes it owns the record. Personal planners do not fail with an error; they fail when you catch the tool being wrong once, stop trusting it, and quietly go back to a text file. Build the read-only version — pull everything in, write nothing back — and you will have the useful eighty percent with none of the ways it eats your data.
What actually breaks
not "if". the specific failures.
- Two-way calendar sync, which is not a database write but an email to everyone on the invite — a bad merge moves a meeting for six other people
- Offline edits, where the phone and the laptop both changed the same task and last-write-wins silently discards the one you actually meant
- Recurring tasks, the classic: "every last weekday of the month", DST, and a completed instance that reappears because the rule regenerated the series
- The Google OAuth token, which expires, gets revoked on a password change, or trips a re-verification and stops syncing without saying so
- Notes, which are the part you would actually mourn, held in your own schema with no export and no version history
- Integrations, each of which is a small API contract with a company that ships breaking changes on their schedule, not yours
- The mobile client, which is where half of capture happens and where a weekend web project cannot follow
Is that you?
the verdict is a default, not a law
- It reads from your calendars and task sources and writes back nothing
- Notes are plain files on disk — markdown in a folder you already back up — rather than rows only your app understands
- You are the only user and one device is the source of truth
- You would be fine losing the whole thing tomorrow, because the data lives somewhere else
- It creates or moves calendar events that other people are invited to, and you have not tested what a failed sync does to their invitations
- It is the only home for your notes, with no export and no backup
- You need it on a phone, which is where most tasks actually get captured
- You are planning to sync three systems bidirectionally without deciding, in writing, which one wins a conflict
If you build it anyway
the checklist, then the prompt that enforces it
- Read-only first, and stay there as long as you can stand it. A unified view of five sources is most of the value and none of the destructive failure modes.
- Pick one system of record per object type before writing a line — calendar events belong to Google, tasks belong to you — and never let two systems own the same field.
- Notes as files, not rows. Markdown in a folder gets version control, cloud backup and a future for free, and it means abandoning the project costs you nothing.
- When you do write back, make every write idempotent and keyed on a stable external ID, so a retry updates rather than duplicates. Duplicated calendar events are visible to everyone you invited.
- Store all times in UTC with the originating zone, and write tests for a recurring task that crosses a DST boundary before you write the UI for it.
- Give conflicts a visible resolution rather than a silent winner: keep both versions, mark the row, and let yourself choose. Silent data loss is what ends the trust.
- Back up the database on a schedule and test a restore once. A personal tool with no restore path is a diary in a single file.
- Cap the integrations at the two you actually use. Every additional connector is a permanent maintenance subscription you pay in evenings.
I am building a personal planner: calendar, tasks and notes in one view, with
a command palette. It is for me alone. Build it so it cannot quietly lose or
duplicate anything, and argue with me when I ask for the risky version.
1. Start read-only. Pull calendars and task sources in and render them; do not
write anything back until I explicitly ask. Tell me which features I lose.
2. Notes are markdown files in a folder I choose, not rows in your database.
Every note keeps its own file so my editor, my backups and git all still
work if this app disappears.
3. Declare the system of record per object before coding: which store owns
event times, which owns task state, which owns tags. Write it in the README
and refuse to let two systems own the same field.
4. When I do ask for calendar writes, warn me first that creating or moving an
event mails everyone on the invite, then make every write idempotent and
keyed on a stable external ID so a retry cannot duplicate an event.
5. Conflict handling is explicit: keep both versions, flag the item, let me
pick. Never last-write-wins silently.
6. All timestamps in UTC with the origin zone stored alongside. Add tests for a
recurring task across a DST change and for "last weekday of the month"
before building any recurrence UI.
7. OAuth tokens go in the OS keychain, never in the repo or a plain config
file, and a refresh failure must surface in the UI — a sync that has been
dead for a week must not look like a quiet day.
8. Export before polish: one command that dumps every task, note and setting to
JSON plus the markdown folder.
9. Backups nightly, and show me the restore command working before we move on.
10. Out of scope: sharing, multi-user, mobile push, AI meeting notes. If I ask
for meeting transcription, stop — recording other people is a separate
question with consent law attached.That one keeps you out of trouble. For the prompt that actually builds it, canivibecodeit.com has one.
their build prompt ↗Or don’t build it
the boring option, and the way back out
When you want it on your phone, or the moment you notice you are keeping a parallel list because you do not quite trust the app. $10 a month buys mobile clients, offline sync that has been debugged against real conflicts, and the connectors staying alive when Google changes an API — which is the whole of the work you were not going to enjoy. Routine's free tier covers the single-user basics too, so trying theirs first costs nothing but an evening.
$10/mo is cheaper than your weekend.
Keep notes as markdown files and tasks in a format you can dump to JSON, and treat every connected calendar as canonical rather than as something you mirror. Then abandoning the project is deleting an app: the notes are still in a folder your backups already cover, the events are still in Google, and the only loss is the layout you liked. If you go the other way — notes in your own tables, tasks that exist nowhere else — the exit is an export script you will have to write on the day you least want to.
Self-hostable task manager with lists, kanban, recurring tasks and a CalDAV interface.
Local-first desktop planner with time boxing, CalDAV and issue-tracker imports — the closest open analogue to the single-user daily-planning shape.
Questions
How is this different from the Morgen entry?
Morgen's entry is about the calendar half — one day view over several calendars, and the moment two-way sync starts mailing your colleagues. Routine adds the note store and the command palette, which is where the personal cost sits instead: the calendar can be re-read from Google, but the note you wrote at midnight only exists in your app. Read them together and the guardrail is the same one from both directions — let other systems own what they already own.
Is the command palette really the easy part?
Yes, and it is also most of why people love these apps, which is the trap. Fuzzy matching over your own objects is an afternoon with a decent library, and it makes the prototype feel finished. Nothing about it helps with sync, conflicts, recurrence or mobile — the four things that decide whether you are still using the tool in March.
Every week, someone ships something they shouldn’t have.
New verdicts, the worst thing that landed in the trap, and the occasional incident report. No other email, ever.
Tasks, habits, a timer. Three small features you will actually use because you chose them.
A personal task manager is the app every developer builds. Yours will fit your brain better.
A unified day view is one sitting. Two-way sync is a machine that emails your colleagues every time it is wrong.
last reviewed 2026-08-04 · verdict is editorial and unsponsored · shared entry data from canivibecodeit under MIT · not legal advice