Developer prototypes personal apps using local-first sync and LLM-assisted coding

The developer built three personal apps, Toucan Music, Places, and People, using a local-first architecture that prioritizes device-resident data with optional sync to a self-hosted server. This avoids cloud lock-in and reduces operational complexity compared to traditional SaaS backends. The choice of Yjs for sync and Hocuspocus as a lightweight server reflects a pragmatic trade-off: while the setup works for personal use, the opaque binary format in the SQLite database complicates debugging and backups. For engineers considering similar projects, this approach eliminates vendor dependencies but requires comfort with less transparent data management.

LLM-assisted coding played a central role in implementation, with the developer using Claude Opus to generate code from written plans and design artifacts. The workflow relied on strict type checking and 100% test coverage to compensate for the LLM’s tendency to introduce subtle bugs. However, the process still demanded extensive manual QA, particularly for UX polish, dozens of iterative tweaks were logged during real-world use. This suggests that while LLMs can accelerate prototyping, they don’t yet reduce the human effort required for refinement. The developer’s workaround for token limits (using `!sleep` commands) also highlights the friction in current LLM tooling for sustained development sessions.

The apps were delivered as progressive web apps (PWAs), eliminating the need for separate native mobile and web codebases. This simplified deployment but introduced browser-specific limitations: the PWA installed correctly via Chrome but failed in Firefox. For engineers, PWAs offer a compelling alternative to native development, but compatibility gaps remain a risk. The local-first architecture further reduced backend complexity, though the lack of standardized personal sync server software (like a Nextcloud equivalent) forced a custom solution. This underscores a broader gap in the ecosystem: while local-first tools exist, they lack the polish and interoperability of mainstream cloud services.

The project’s limitations reveal where LLM-assisted and local-first workflows still struggle. The opaque sync format in Hocuspocus complicates data management, and the manual QA burden makes scaling beyond personal use impractical. Additionally, the reliance on a single developer’s domain knowledge (e.g., for UX feedback) suggests these tools are better suited for solo projects than team collaboration. For engineers, this case study demonstrates a viable path for bespoke tools but also highlights the trade-offs: reduced infrastructure overhead comes at the cost of maintainability and scalability.

The broader implications touch on the future of personal software development. The developer’s frustration with cloud lock-in (e.g., Google Maps lists) and proprietary formats (e.g., Spotify’s folder limitations) reflects a growing demand for alternatives. Local-first tools and LLMs lower the barrier to creating custom solutions, but the lack of standardized sync servers and the QA burden remain obstacles. For engineers, this signals an opportunity to build better tooling for personal use cases, whether by improving sync protocols, automating QA, or refining LLM-assisted workflows. The project’s success as a prototype suggests these gaps are surmountable, but not yet solved.