Overview
I designed, built, and launched a complex team platform. Solo, with AI as my engineering org.
BaseThread is a shared brain for teams and the AI tools they already use. Every assistant, Claude Code, Cursor, ChatGPT, Copilot, Windsurf, reads the team's context before a session and writes back after, over MCP. The result is a living record of what was decided, what shipped, and who owns what, that every teammate's AI stays current on. No scraping, no logging, no standups. The AI is the integration.
What is different is the scope one person carried. I made every product, design, and business call and directed a fleet of AI agents to build all of it: a Next.js web app, a native macOS app with a Rust daemon, a hosted MCP server, a design system, a marketing site, billing, RBAC, and an in-app docs platform. Zero engineers, empty repo to live product with real users in five weeks.
Preview
A 30-second look
This promo was designed and rendered programmatically in Remotion, a React framework for code-driven video. Same discipline as the product: designed in code, no timeline editor.
The Problem
Everyone's AI is brilliant in isolation, and blind to the team.
AI made every individual faster and teams more fragmented. Every session, every tool, every new hire re-explains the same context from scratch. Agents ship work with no idea what the rest of the team's agents just did. Decisions get contradicted because nobody wrote down what was settled versus merely discussed. Docs rot, the wiki is wrong, and the one person who knew the architecture already left.
The context that teams run on lives in scattered chat logs and people's heads. Individual productivity went vertical. Team alignment fell off a cliff.
What I Built
Your team's second brain, written by every AI tool.
BaseThread organizes a team into a clean hierarchy, from company mission down to a single project brief, and layers three live streams on top of it that the team's AI keeps current. One system runs both personal and team modes on the same architecture.
The Core
The work writes itself down.
The heart of BaseThread is the Activity and Decisions Ledger. As your AI finishes real work, it logs what happened and what was decided, in structured, scoped, permissioned entries that every other teammate's AI can read. When two agents log things that conflict, "we use TypeScript" against "we are moving to Rust," a harmonization pass catches it, flags the contradiction, and lets a human pick what stands. The ledger stays a source of truth instead of a pile of noise.
Witness
AI-witnessed. Entries are created by the tool doing the work, at the moment it happens.
Log
Scoped and permissioned. Writes activity, decisions, and tasks as structured entries every teammate's AI can read.
Harmonize
The cloud reconciles across the team. An automated pass finds duplicates, conflicts, and decisions that supersede older ones.
Resolve
When decisions clash, a human settles which one holds, on the record. The ledger stays a source of truth, not noise.
Push back
Every member's tools get the latest. The same ledger is served to Claude, Cursor, ChatGPT, and the rest, identically.
The Architecture Bet
Local-first for speed and privacy. Hosted for reach. Both, at parity.
I built the local path first: a native macOS app with a Rust daemon that mirrors the team's context to your machine and serves it to your AI over a local socket, in milliseconds, offline, nothing leaving your network. Then a hosted path at mcp.basethread.ai, so anyone can connect from a browser-only tool with nothing to install. The hard part is not building two servers, it is keeping them identical. Every tool and behavior ships to both in the same change, so the paths never drift. Same 27 tools, same semantics, your choice of transport.
Local MCP · on your Mac
- Native Rust daemon, always on
- Millisecond latency, works offline
- Context never leaves your machine
- Claude Code, Cursor, Windsurf, Copilot
Remote MCP · hosted
mcp.basethread.ai, nothing to install- Available anywhere, browser-only friendly
- OAuth-secured, same permissions
- ChatGPT, Claude, agents, browser AI
27 tools · both paths · zero drift
The Payoff
Ask anything. Your AI already knows.
A teammate opens Claude and asks what the engineering team shipped last week. It answers from BaseThread, cites the ledger, and names who did what, without anyone writing a status update. That is the whole product in one screen.
Not a Mockup
A real, running workspace. Not slides.
Everything here is the actual shipped product: a live dashboard with an AI-written summary, coded activity charts, role badges, and a fully interactive context graph you can explore hub by hub.
The 14-day chart is coded to the three streams: Decisions (green), Activity (cyan), Tasks (pink).
See It End to End
Five minutes through the whole thing.
An end-to-end look at the local MCP in action: me working alongside Claude Code as it reads and writes the team's shared context, the hierarchy, the live ledger, and the context graph, to keep up with the rest of my team.
The Hard Parts
The unglamorous depth that makes it real.
A shared brain for teams is only trustworthy if permissions, governance, and edge cases are handled properly. I treated this like enterprise software from the first commit.
RBAC at four layers
Gated in the UI, client, server, and database. Four checks, one rule.
Roles & scoped membership
Owner, Admin, Contributor, Viewer, each scoped to where they belong.
Harmonization
Contradictions surfaced and resolved on the record, not buried.
File locking
Optimistic concurrency and per-file locks. Nothing silently overwritten.
Per-session scope
Multiple AI sessions work in different areas without clobbering.
16 notification types
Invites, billing, activity, meetings, all preference-gated.
Billing & payments
Free trials, paid workspaces, seats, and the full billing state machine.
Multi-tenant isolation
Every workspace's data walled off from every other, isolated end to end.
How I Built It
No team. I ran a fleet of agents like a studio.
Proof of what one experienced designer and product leader can ship when AI handles implementation and you supply the judgment. I directed; AI wrote the code.
The AI Stack
One director. A fleet of agents. A full product.
Claude — strategy and architecture
Wrote the PRD, shaped the system design, researched macOS and MCP internals, and was my thinking partner on every hard call.
Claude Code — implementation
Built every line: the Next.js app, the Rust daemon, the MCP servers, RBAC, billing, the design system, and the marketing site.
Remotion — the promo
The launch video was designed and rendered in code, no video editor.
What I directed
AI wrote the code. I made every decision that shaped the product.
- Product strategy What to build, what to cut, how to sequence it, and the mid-flight repositioning.
- UX and interaction Onboarding that feels like live magic, the dashboard, the graph, every flow.
- Visual design and brand The violet system, dark mode from day one, the whole design language.
- Architecture calls Local-first then hosted, the ledger model, RBAC at four layers, MCP parity.
- Marketing and positioning The site, the messaging, a full content library, the launch.
- Business Pricing, tiers, beta gating, the go-to-market.
- Quality bar Reviewed and refined every surface until it felt right.
The meta move: I dogfooded the idea to build the product.
I ran my entire solo build on an externalized, AI-written context system: a living ledger of decisions, an active task list, session logs, and a memory of hard-won learnings, all read at the start of every session and written back at the end. In other words, I used a shared-context-for-AI workflow to build the shared-context-for-AI product. The philosophy proved itself on its own construction.
Research & Validation
Built with the market, not in a vacuum.
Customer obsession was not a launch afterthought, it shaped the build. Throughout, I pressure-tested BaseThread with fellow founders and AI-native leaders, the people who live in these tools every day. I put the architecture, the positioning, and the real workflows in front of them, and folded their feedback back into how the product scales and where it fits.
Under the Hood
More than it looks
The stack a solo builder does not usually get to touch, all of it, shipped.
Doppler
- Dual-path MCP server 27 tools exposed identically from a Rust daemon and a hosted endpoint, kept at strict parity.
- AI-witnessed ledger Structured decision, activity, and task capture written by the team's own AI tools.
- Harmonization pipeline Automated detection of duplicate, conflicting, and superseding decisions across the team.
- Four-layer RBAC UI, client, server, and database row-level policies enforcing one permission model.
- Native macOS app A signed, notarized Tauri app with a Rust daemon, a menu-bar surface, and a one-click auto-updater.
- Local sync engine The cloud workspace mirrored to on-device files and served to your AI in milliseconds, offline included.
- Real-time and safe editing Presence, optimistic concurrency, and file locking so nothing is silently overwritten.
- In-app docs platform A full customer documentation system with its own content layer and component set.
The Range
Every discipline it took to ship. One person.
The point of BaseThread is not just that it works. It is the breadth of disciplines one person covered to ship it.
Design
A complete design system, dark mode from day one, a distinct violet brand, and an immersive marketing aesthetic.
UX & Product
Onboarding that feels like live magic, getting-started flows, a public interactive demo, and a dashboard people actually read.
Marketing
A full marketing site, an interlinked library of SEO content, an integrations showcase, and the launch narrative.
Infrastructure
A monorepo with CI/CD, a two-environment deploy topology, secrets management, and cron-driven background jobs.
AI Engineering
A provider abstraction, prompt design for harmonization and compression, embeddings-backed retrieval, and cost controls.
Docs & DX
An in-app docs platform, a build guide, and a self-documenting context system for the whole project.
The Plan
Sequenced like a company, not a hackathon.
I broke the build into phases, each with a clear ship criterion, and did not move on until it was met.
1 · Bootstrap
Repo, conventions, and the externalized context system in place before a line of feature code.
2 · MVP core
Auth, the hierarchy, the first editors, and the local MCP path. Ship criterion: Claude Code reads the team's context end to end.
3 · The ledgers
Decisions and Activity streams live at every scope, with full create, read, update, and delete.
4 · Remote MCP + foundations
The hosted path at mcp.basethread.ai, OAuth, and the billing state machine, at parity with local.
5 · Harmonize + harden
The conflict-resolution pipeline, multi-tenant security sweep, and beta hardening.
6 · Launch
Public beta opened, first customer onboarded, live on production with real users.
Results
One builder. Zero engineers. A real, launched product.
And roughly 120,000 lines of code across all four surfaces. Shipped solo.
Reflection
The real product was proving what one person can now ship.
BaseThread is a complex, multi-surface platform that would normally take a funded team. I designed it, architected it, built it through AI, marketed it, and launched it alone, in a five-week build-out. It was a deliberate test of the ceiling: how much product judgment, taste, and range can one experienced builder apply now that AI handles the implementation. The answer, it turns out, is a whole company's worth. This is how I work now.