# How to Vibe Code Your Own Capacities (and Stop Paying for It)

> A studio for your mind

- Site: https://capacities.io
- Category: Productivity
- Platforms: Web app, macOS app, Windows app
- Verdict: **Solid side project** (65/100 vibecodeable)
- Estimated effort: 3-4 weeks of focused evening work

## Verdict

Build a personal subset for your own single-user use, but keep paying if you rely on the polished multi-platform sync and mobile apps.

Replicating Capacities as a personal web application is a rewarding challenge because its core value proposition—typed objects instead of folders—can be modeled cleanly in a local SQLite database using Turso or better-sqlite3. However, you will hit serious friction getting a block editor and a real-time bi-directional backlink index to feel as snappy and frictionless as the original product. The AI features, calendar connectors, and mobile apps will require considerable scaffolding time that far exceeds the $10/month subscription cost if your goal is pure utility rather than learning.

### What you can't replicate

- The exact polish and native performance of their multi-platform desktop/mobile wrapper
- The embedded community and direct integration ecosystem
- Continuous background maintenance and bug fixes by a dedicated team

## What it does

Object-oriented personal knowledge management application that replaces folders with dynamic networked objects.

### Core features

- Object-oriented data architecture (typed objects with custom properties)
- Bi-directional linking and automated back-linking panel
- Visual graph view showing relationship clusters
- Daily note inbox with automatic timeline threading
- Block-based rich text editor (Notion-style)
- Custom templates per object type
- Global search engine and local-first sync

## The business

### Pricing

- Basic: Free — Core object-oriented note-taking with unlimited spaces and objects
- Pro: $9.99/mo — Advanced task management, AI assistant, calendar integrations, and smart queries
- Believer: $12.49/mo — Early beta access and direct mission support

Founded 2022.
Team size: ~7.

## The hard parts

- Building a performant client-side graph database mapping dynamic typed objects and bi-directional edges
- Implementing a fluid block-based rich text editor with embedded inline markdown and backlink triggers
- Orchestrating offline-first local persistence with background synchronization without data corruption
- Rendering a performant interactive force-directed graph view of knowledge nodes in the browser

## How to vibe code Capacities

### Prerequisites

- Node.js (free): Required for running the Next.js runtime and package manager
- GitHub (free): Source control and deployment pipeline integration

### Recommended AI tools

- Claude Code: Best-in-class terminal agent for scaffolding complex database schemas, APIs, and React components
- Cursor: Ideal for iterative UI styling and fine-tuning the block editor components

### Stack

- Frontend: Next.js with Tailwind CSS and Lucide icons
- Backend: Next.js Server Actions / API Routes
- Database: Turso (SQLite at the edge) with Drizzle ORM
- Auth: better-auth
- Payments: None (personal-use clone)
- Other: TipTap or BlockNote for block-based editing, Visx or D3 for graph visualization

### Hosting

- Vercel (Hosting the Next.js frontend and serverless API endpoints): $0/mo (Hobby tier)
- Turso (Serverless SQLite database for storing typed objects, properties, and markdown blocks): $0/mo (Free tier)

### Build guide

1. **Project Scaffolding and Database Schema** — Initialize the Next.js project with Tailwind CSS and set up Drizzle ORM with Turso. Define the core relational schema for objects, object types, properties, blocks, and bidirectional links.

```
Initialize a new Next.js 16 project with TypeScript, Tailwind CSS v4, and App Router. Set up Drizzle ORM connected to a Turso SQLite database. Create the following database tables: `object_types` (id, name, icon, color, schema_definition), `objects` (id, type_id, title, created_at, updated_at), `object_properties` (id, object_id, property_name, property_value), `blocks` (id, object_id, parent_id, type, content, position), and `links` (id, source_object_id, target_object_id). Include migration files and a basic seed script with default object types like Person, Book, Project, and Meeting.
```

2. **Authentication and User Shell** — Implement self-hosted authentication using better-auth and build the core application layout with a sidebar for spaces, daily notes, and custom object types.

```
Install and configure `better-auth` in the Next.js app with email/password authentication backed by our Turso database. Create a clean dashboard shell layout featuring a collapsible left sidebar. The sidebar must list: Daily Notes shortcut, All Objects view, Spaces switcher, and dynamically loaded Custom Object Types fetched from the `object_types` table. Add a top navigation bar with a global search trigger.
```

3. **Daily Notes & Object Creation Engine** — Build the daily notes capture ritual and the modal/page system for creating custom typed objects with specific property schemas.

```
Implement the Daily Notes feature: visiting `/app/daily` automatically retrieves or creates a note for the current date formatted as an object. Build an object creation modal that allows users to pick an object type (e.g. Book, Person, Project), input a title, and fill out custom metadata fields defined in that object type's schema. Store these fields in `object_properties` and render them cleanly at the top of the object detail view.
```

4. **Block-Based Rich Text Editor & Backlink Parser** — Integrate a block-based editor supporting markdown-style commands and implement a regex-based parser that detects `[[object name]]` mentions to generate automatic bi-directional links.

```
Integrate BlockNote or TipTap into the object detail view to serve as the block-based document editor. Implement an extension or custom command parser that listens for `[[` triggers to search existing objects in the database and insert a bi-directional link. Upon saving an object's content blocks, parse all `[[object_id]]` mentions and update the `links` table so that a corresponding backlinks panel can display every referencing object.
```

5. **Backlinks Panel & Graph View Visualization** — Create the sidebar backlinks component for object pages and an interactive graph visualization showing nodes and edges.

```
Build a Backlinks component that queries the `links` table and displays all objects referencing the currently viewed object. Next, build a `/app/graph` route using an interactive force-directed graph library (such as `react-force-graph` or D3) that fetches all objects and links from the backend and renders them as an interactive constellation of connected knowledge nodes, allowing users to click a node to navigate directly to that object.
```

6. **Global Search and Export Functionality** — Add a command-palette style global search engine and a complete JSON/Markdown export utility to ensure data portability.

```
Implement a global search command palette (triggered via Cmd+K) that queries object titles and block content across the entire database with instant debounced results. Add an export settings page with a button that packages all user spaces, objects, blocks, and properties into a downloadable ZIP archive containing structured JSON and Markdown files with frontmatter.
```

### Cost vs paying

**Starting costs (one-time):**

- Custom domain (optional): $12/yr
- Total: ~$12 one-time

**Ongoing costs (monthly):**

- Vercel & Turso Hobby tiers: $0/mo
- Total: $0/mo

- Paying for the SaaS instead: $9.99/mo
- Build time: 25-35 hours
- AI tool credits: $20/mo (Claude Pro)
- Break-even: 1 month of Pro subscription

## Sources

- [Capacities Official Website](https://capacities.io)
- [Capacities Pricing & Plans Overview](https://capacities.io/pricing)