Omplish - task planner with an AI companion

Omplish is a local-first task planner with an AI companion. Break plans into doable steps, stay in motion, and feel accompanied while you do — with warm, grounded encouragement.

Comment

Inspiration

Omplish started with a frustration: productivity tools are supposed to reduce mental load, yet many introduce more of it through cluttered interfaces, rigid workflows, subscriptions, and AI features that take too much control.

We wanted to build a calmer alternative—a private planning app that remains useful without an account, internet connection, or AI subscription. AI should help users move forward, but it should never silently control their data.

That idea became Omplish, with Ameth as its optional AI companion. Our guiding principle was:

$$ \text{Useful AI} = \text{AI assistance} + \text{Deterministic rules} + \text{Human approval} $$

Building everything in under 70 hours

Our biggest constraint was time: we had fewer than 70 hours to build the project from scratch, with only two people on the team.

That forced us to be ruthless about scope. Instead of attempting every productivity feature we imagined, we prioritized one complete and trustworthy workflow:

  1. Capture tasks and brain dumps.
  2. Organize and schedule the work.
  3. Ask AI for a structured plan when needed.
  4. Review every suggested change.
  5. Apply only what the user approves.

We divided the work around product direction, interface design, architecture, implementation, testing, and release preparation. We also used Codex as an engineering collaborator to accelerate research, specification writing, code generation, debugging, and verification. This allowed our two-person team to work with much greater leverage while keeping all important product decisions under human control.

How we built it

We built Omplish as a local-first desktop application using:

  • Next.js, React, and TypeScript
  • Electron for macOS and Windows
  • PostgreSQL and Drizzle ORM
  • Zod for runtime and AI-output validation
  • The OpenAI Responses API with Structured Outputs
  • Tailwind CSS and accessible UI primitives
  • Vitest and Playwright for automated verification

The AI planner is a proposal pipeline rather than an autonomous agent:

Brain dump
    ↓
Minimal authorized context
    ↓
Structured AI response
    ↓
Schema and semantic validation
    ↓
Deterministic scheduling
    ↓
Editable proposal
    ↓
Explicit user approval
    ↓
Transactional apply

The model helps interpret messy human input, but deterministic application code remains responsible for scheduling, authorization, conflicts, time zones, and database writes.

No AI-generated change is applied automatically. Users can inspect, edit, reject, or approve the proposal first. Omplish also continues to support its manual workflows when no OpenAI API key is configured.

Challenges we faced

Controlling scope

With fewer than 70 hours, our greatest risk was building many incomplete features. Task management can quickly expand into recurrence, habits, reminders, collaboration, analytics, synchronization, and dozens of secondary workflows.

We had to continuously separate the long-term vision from what we could implement and verify within the hackathon.

Making AI output safe

Generating a convincing plan was easy. Generating one that could safely modify real user data was much harder.

Structured output guarantees shape, not correctness. We therefore treated model responses as untrusted input and added semantic validation, deterministic scheduling, stale-data checks, explicit review, and transactional application.

Handling time correctly

Calendar logic became one of the most difficult engineering areas. All-day tasks, timed tasks, durations, time zones, and scheduling conflicts needed one consistent representation. Small mistakes here could make an otherwise polished planner unreliable.

Building a local desktop runtime

Packaging Next.js, Electron, and PostgreSQL into a local-first desktop architecture introduced additional work around process startup, offline behavior, secrets, security boundaries, and graceful failure.

Balancing speed with quality

The short deadline encouraged shortcuts, but privacy, authorization, and data integrity were areas where shortcuts would undermine the entire project. We had to choose carefully where to simplify while preserving the boundaries that made Omplish trustworthy.

What we learned

We learned that a small team can build a surprisingly ambitious product in a short period when the scope and system boundaries are explicit.

We also learned that responsible AI products need strong non-AI foundations. Structured Outputs are valuable, but reliable behavior still requires deterministic rules and human oversight:

  • AI interprets ambiguous intent.
  • Application code enforces invariants.
  • The user makes the final decision.

Most importantly, fewer than 70 hours taught us that constraints can improve a product. We could not build everything, so we focused on the experience that mattered most: helping someone turn mental clutter into a clear, reviewable plan without surrendering control of their data.

Built With

Share this project:

Updates