Capacities logo

How to vibe codeCapacities

A studio for your mind

capacities.io

Productivity

Web appmacOS appWindows app
65/ 100
Solid side project

The verdict: can you vibe code Capacities?

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.

Estimated effort: 3-4 weeks of focused evening work

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

Founded

2022

Raised

Team

~7

Cheapest paid tier

$9.99/mo

What Capacities 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

  • BasicFree
  • Pro$9.99/mo
  • Believer$12.49/mo

Funding

Unknown / bootstrapped

Pay vs build, cumulative

Break-even at month 2 — after that, every month is money kept.

The hard parts of vibe coding Capacities

  • 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 vibecode Capacities

Prerequisites

  • Node.jsfree

    Required for running the Next.js runtime and package manager

  • GitHubfree

    Source control and deployment pipeline integration

AI coding tools

Recommended stack

FrontendNext.js with Tailwind CSS and Lucide icons
BackendNext.js Server Actions / API Routes
DatabaseTurso (SQLite at the edge) with Drizzle ORM
Authbetter-auth
PaymentsNone (personal-use clone)
OtherTipTap or BlockNote for block-based editing, Visx or D3 for graph visualization

Hosting & infrastructure

VercelHosting the Next.js frontend and serverless API endpoints$0/mo (Hobby tier)
TursoServerless SQLite database for storing typed objects, properties, and markdown blocks$0/mo (Free tier)

Build guide

  1. 01Project 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. 02Authentication 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. 03Daily 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. 04Block-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. 05Backlinks 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. 06Global 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 for Capacities

What will you build it with?

Est. 12.5M in / 2.8M out tokens· Includes access to introductory usage of the default model with dynamic rate limits.$0

Starting total with Claude Code$0 one-time

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 Capacities

$9.99/mo

Your time to build

25-35 hours

AI tool credits

$20/mo (Claude Pro)

Break-even

1 month of Pro subscription

Vibe code Capacities: FAQ

Can you vibe code Capacities yourself?
Solid side project — 65/100 vibecodeable. 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.
How long does it take to vibe code Capacities?
3-4 weeks of focused evening work — roughly 25-35 hours of hands-on time with an AI coding agent.
How do you build your own Capacities?
Scoped to personal use: Next.js with Tailwind CSS and Lucide icons on the front, Next.js Server Actions / API Routes behind it, Turso (SQLite at the edge) with Drizzle ORM for data. Follow the 6-step build guide on this page — each step has a paste-ready prompt for an AI coding agent.
How do you code your own Capacities without being an expert?
Use an AI coding tool (Claude Code or Cursor) and work in small steps: scaffold, data model, core screens, then deploy. Realistic effort: 3-4 weeks of focused evening work. The prompts on this page are written so the AI does the heavy lifting.
How much does it cost to vibe code Capacities instead of paying?
About ~$12 one-time to start and $0/mo to run, versus $9.99/mo for Capacities. Break-even: 1 month of Pro subscription.
What stack should you use to vibe code Capacities?
Next.js with Tailwind CSS and Lucide icons; Next.js Server Actions / API Routes; Turso (SQLite at the edge) with Drizzle ORM; plus TipTap or BlockNote for block-based editing, Visx or D3 for graph visualization.

Sources

Alternatives & community builds

All alternatives →