I used AI to build a native macOS app because I kept missing meetings.
Not because I wanted to make an AI demo. I wanted a small tool that would interrupt me at the right moment, show me what was next, and let me join without opening three different apps.
That tool became Meetly: a macOS menu bar app with fullscreen meeting reminders, a Quick Panel, one-click joining, and no subscription.
This is the developer story behind it: where AI accelerated the work, where it confidently made the wrong assumptions, and why the product still needed a human driving the decisions.
Watch the demo
Here is the full workflow in action: staying focused in the terminal, seeing the fullscreen reminder, and joining the meeting without hunting through Calendar.
Watch the Meetly demo on YouTube
Start with the failure mode, not the feature list
The initial specification was one sentence:
I am deep in a coding session. My next meeting is about to start. Make it impossible to miss without distracting me for the rest of the day.
That led to a deliberately small first version:
- Read events from macOS Calendar.
- Identify the next meeting.
- Show a fullscreen reminder shortly before it starts.
- Surface the meeting link.
- Let me join, snooze, or dismiss it.
- Stay in the menu bar instead of becoming another Dock window.
AI is very good at expanding a vague idea into a list of features. That is also dangerous. If I had accepted every suggestion, Meetly would have become a calendar replacement before it had solved the reason I started it.
The first product decision was therefore not technical: keep the core loop narrow.
Where AI helped most
I used AI as a fast pair programmer and reviewer throughout the build.
It was particularly useful for:
Exploring macOS APIs
Calendar access, notification timing, menu bar lifecycle, fullscreen windows, global shortcuts, permissions, and multi-display behavior all have details that are easy to miss.
AI helped me create small experiments instead of guessing inside the main app. A focused question such as “show the next event from EventKit and handle an event with no meeting URL” produced a much faster starting point than searching through unrelated examples.
Turning interaction ideas into state machines
The reminder looks simple, but it has states:
scheduled → approaching → visible → joined
↘ snoozed
↘ dismissed
AI helped enumerate transitions and edge cases: an event gets deleted, the Mac wakes from sleep, the user changes time zones, a meeting has no link, or two displays reconnect while the reminder is visible.
That kind of enumeration is one of the highest-leverage uses of AI in app development. It does not replace design, but it makes invisible states visible earlier.
Generating repetitive UI and test scaffolding
Once the behavior was clear, AI was useful for the boring parts: view structure, model transformations, previews, test data, error messages, and refactors.
The important constraint was to ask for small changes. “Build Meetly” is a bad prompt. “Add a pure function that maps an event into a reminder state, then write tests for missing links and past events” is much easier to review.
Where AI was confidently wrong
AI-generated code often looked plausible before it was run.
The most common problems were not syntax errors. They were product and platform assumptions:
- Treating a menu bar app like a normal Dock application.
- Assuming a notification behaves the same across focus modes and displays.
- Forgetting that Calendar access is permissioned and can be revoked.
- Using a convenient API without considering its behavior after sleep/wake.
- Adding a cloud-backed architecture to a feature that should stay local.
The fix was a tight loop:
- Ask AI for a small implementation or experiment.
- Run it on a real Mac.
- Test the uncomfortable cases.
- Read the generated code line by line.
- Keep, rewrite, or discard it.
AI reduced typing. It did not remove verification.
The architecture stayed intentionally boring
Meetly is a native macOS menu bar app. Its central data flow is intentionally small:
macOS Calendar / Reminders
↓
local event model
↓
reminder + Quick Panel
↓
join / snooze / dismiss
The app does not need a cloud calendar database to solve its core problem. Calendar data stays on the Mac. Optional cross-Mac sync uses the user’s own iCloud container rather than a codeonholiday backend.
That architecture was a product decision as much as a privacy decision. Fewer services mean fewer things to deploy, monitor, authenticate, and explain.
The Quick Panel came from using the first version
The fullscreen reminder solved the urgent problem: do not miss the call.
Using it exposed a second problem: I also needed to plan the time between calls.
That became the Quick Panel. It shows what is next, supports a live countdown, and can stay pinned above other windows without opening Calendar.
This was a useful reminder that AI can help implement a roadmap, but usage creates the roadmap. The best next feature was not the one an assistant generated. It was the friction I encountered after the first version shipped.
What I would do differently
If I built Meetly again, I would add real-device testing earlier.
Desktop apps have environment-dependent behavior that a clean development session hides: permission changes, multiple monitors, sleep and wake, Focus modes, calendar refresh delays, and links from different conferencing providers.
I would also define the product boundaries earlier. AI naturally suggests integrations and features. Saying “not now” is an engineering skill when building with an always-available idea generator.
The result
Meetly now does one job well:
Let me focus until a meeting actually matters, then give me an interruption I cannot miss.
The free version includes fullscreen reminders, a menu bar view, one monitored calendar, quick join, snooze, and the Quick Panel. Pro adds unlimited calendars, Apple Reminders, quiet hours, screen-share privacy, and iCloud sync across Macs. It is a one-time purchase, not a subscription.
If you want to see the finished app, Meetly is free to download for macOS 14+.
The larger lesson for me is simple: AI made the build loop faster, but the product still came from choosing a real problem, rejecting unnecessary complexity, testing on real hardware, and taking responsibility for every behavior that ships.
If you are using AI to build a native desktop app, I would love to hear what it gets wrong most often in your workflow.
