DevPlane

Customer

Solo founders and small teams running heterogeneous AI coding tools across a portfolio of products, plus the cross-repo engineering hubs that need patterns, maps, decisions, and capabilities legible across every product in that portfolio.

Problem · external

AI coding tools measure productivity from the agent's side — lines produced, tasks completed, time-to-PR — and there's no operator-side cockpit that catches what an operator running multiple agents actually has to do. Meanwhile every repo accumulates its own patterns, maps, and decisions; most stay locked inside the repo that produced them.

Problem · internal

The feeling that the tools don't know about each other and that the same primitive is being rebuilt five times across five products without anyone noticing.

Problem · philosophical

If AI-productivity claims rest on agent-side measurements alone, the Ironies of Automation will go uncaught.

Guide

A local dashboard + MCP server + CLI + Chrome extension orchestrating one target project at a time, plus a cross-portfolio documentation hub — patterns, architecture maps, session handoffs, assignment registries, API surfaces, decisions, capabilities catalogs — legible across every product in the portfolio. The continuous coordination-event log doubles as the research apparatus for the C1 risk-compensation field study (pre-registered, Bainbridge 1983).

Plan

Point `dp` at any repo → multi-tool kanban surfaces the work; agents claim assignments through a registry; completion blocks close each card with structured machine-readable artifacts; cross-portfolio patterns, maps, and decisions are reconciled into one legible surface.

Success

One operator coordinates Cursor + Claude Code + Codex + custom agents through one board; the production telemetry tests AI-productivity claims in pre-registered terms; every new product stands on the last one's shoulders rather than rebuilding from scratch.

Failure avoided

AI-tool productivity claims that systematically miss what the operator does; portfolios where the same primitive is rebuilt five times and nobody notices.

Two convergent problems. AI coding tools' productivity claims rest on agent-side measurements — lines produced, tasks completed, time-to-PR. If the Ironies of Automation are operative (operator vigilance falling as agent reliability rises), those measurements systematically overstate net effect. There is no operator-side cockpit catching the loss. And on the portfolio side, every repo accumulates its own patterns, architecture maps, handoffs, and decisions — most of which are unreachable from any other repo. The result is rebuilding the same primitive five times across five products and not noticing.

A local dashboard + MCP server + CLI + Chrome extension that orchestrates day-to-day work inside one target project (kanban, actions, dispatch, session reports). A multi-agent kanban with a completion-block protocol that tracks per-card execution across heterogeneous AI tools. Two-phase actor handoff (builder → reviewer) where the second transition requires an artifact only the reviewer can produce. Cross-tool sync via a hub SDK so an operator coordinates Cursor, Claude Code, Replit, and other agents through one board. The continuous production telemetry that runs the C1 risk-compensation field study — a pre-registered test of Bainbridge 1983 in real coding work, with hypotheses, analysis plan, and falsification criteria specified before data accumulates. The cross-project documentation hub: pattern library (~20 production-validated patterns), architecture maps per repo, session-handoff archive, assignment registry across repos, API registry, decision log, capabilities catalog, and the Portfolio Capability Platform Playbook that governs how every product folder is structured (src/capabilities/<name>/{contracts,core,adapters,ui,tests} with extraction maturity levels 0–3). Performix is the first reference implementation of the doctrine.

• 01Two-phase actor handoff (builder → reviewer) where the second transition requires an artifact only the reviewer can produce — enforces review without trusting it
• 02Coordination-event log as a research instrument, not just an audit trail — the apparatus for the C1 risk-compensation field study
• 03Completion blocks as a protocol — every assignment ends with structured machine-readable completion, not free-text close-out
• 04Hub-and-spoke sync between heterogeneous AI tools so an operator coordinates Cursor + Claude Code + Replit + custom agents through one board
• 05Cross-project documentation hub — patterns, maps, handoffs, assignments, APIs, decisions, and capabilities legible across every repo in the portfolio. Reduces the rebuild-it-five-times tax that solo-cadence multi-product work would otherwise pay.
• 06Capability Architecture Doctrine — the portfolio-wide playbook for structuring applications as compositions of extractable capabilities with contracts, adapters, and props-driven UI. Performix is the first reference implementation; subsequent products inherit the structure.
• 07Coordination-pill extraction (DP-165) — the first substrate-first pill the repo is building toward. The `src/coordination/` boundary is enforced (no outside imports, no `DevPlaneConfig` references; accepts a `CoordinationStorage` adapter). End state: `@devplane/coordination-core` v0.1.0 published to npm; first external consumer planned as the People Analytics Toolbox.
• 08Pattern-propagation stack — `dp patterns` CLI + `devplane_patterns_search` / `devplane_patterns_get` MCP tools + `docs/PATTERNS/MASTER-PATTERNS.md` as the reconciled canonical surface. Patterns are now discoverable from any agent over MCP, from the operator over CLI, and actively reconciled rather than write-only.
• 09Portfolio Brief Protocol — sister repos emit StoryBrand-shaped `docs/portfolio-brief.json` files; the hub syncs them; PA-site renders them as per-project detail pages with staleness badges. Cross-portfolio narrative state is now machine-readable and continuously refreshed rather than scattered through readmes.

1. 2026-05-18Portfolio reconciliation: PAT-113 directives-hub contract mirrored, ~/.devplane/portfolio.json registry refreshed (14 → 15 projects, 7 new capability entries on toolbox), DP-150 closed (e47fef8)
2. 2026-05-18Coordination-pill E-2 (DP-167): migrated audit-log + rate-limit into src/coordination/ under the no-outside-imports boundary (c3fe41c)
3. 2026-05-18Coordination-pill E-1 (DP-166): earmarked src/coordination/ + README defining the extraction boundary for the future @devplane/coordination-core npm package (9cfc4c4)
4. 2026-05-18DP-165 scoping doc: 8-phase coordination-pill extraction plan filed at docs/COORDINATION-PILL-EXTRACTION.md (9821fcf)
5. 2026-05-18DP-148 close: performix re-vendored to segmentation-studio 2.2.0 (ead3fa2)
6. 2026-05-18DP-149: meta-factory OLD/PROD split in registry + memory + mission doc (aa92754)
7. 2026-05-18DP-164: /api/triage/coverage endpoint + dp triage --coverage CLI surface (f446f2f)
8. 2026-05-17Pattern propagation stack: devplane_patterns_search + devplane_patterns_get MCP tools (DP-158), dp patterns CLI (DP-157), devplane patterns reconciled into MASTER (DP-160), P234 toolbox/Light-Mode Design System reconciled (1d2b08c)
9. 2026-05-14Tier 2 portfolio SOTA snapshot pass complete; DP-148/149/150/151 follow-ups filed (c10448a)
10. 2026-05-13DP-129 cross-portfolio pattern catalog refresh (mirror + master + paradigms) — PR #65 merged
11. 2026-05-11DP-139 MCP-control Phase 2: meta-factory adapter + first composite — PR #63 merged
12. 2026-05-08DP-123 cross-portfolio status view — PR #62 merged
13. 2026-05-04DP-110 Vercel deployment of devplane.app hosted dashboard — PR #61 merged

• ·Coordination-pill extraction (DP-165 master). E-1, E-2 DONE; E-3 next — migrate coordination-events.ts + claim-override-events.ts (~468 LOC, SQLite-backed; extends CoordinationStorage with openSqlite(name)). End state: @devplane/coordination-core v0.1.0 published to npm.
• ·DP-104 Research substrate consumer integration. Gated on meta-factory MF-001/002/003.
• ·DP-137 Supabase key drift audit across four repos (needs interactive vercel env pull; not solo-safe).
• ·DP-136 Operator-console visual identity. Deferred under the substrate-first direction.
• ·DP-135 Vercel REST API pattern doc. Low priority, picks up any session.

Two products in one repo: a local operator cockpit (Hono + Server-Sent Events + SQLite + CLI + MCP server + Chrome extension, served at `localhost:4000` by `npm start <project-dir>`) and a cross-portfolio documentation hub (`docs/` — patterns, architecture maps, session handoffs, cross-project assignment registries, API surfaces, decisions, periodic SOTA snapshots, capabilities catalog). The cockpit is the dispatch and telemetry layer; the docs hub is the portfolio's shared engineering brain. The two reinforce each other — the cockpit collects coordination-event data the docs hub turns into pattern recommendations across products. A hosted instance runs on Vercel (Node 22, Hono entry at `src/index.ts`, Postgres via Supabase, Clerk for auth, Stripe for billing, cron routes at `/api/cron/*`). The newest structural posture is the `src/coordination/` boundary: an enforced no-outside-imports zone earmarked for extraction as `@devplane/coordination-core`, accepting a `CoordinationStorage` adapter rather than referencing DevPlane-specific config — the first substrate-first pill the repo is building toward.

Private. The operator-side coordination spine for the multi-app portfolio. Live locally, measuring, instrumented for the C1 field study. Hosted Vercel instance at devplane.dev (Hono entry, Postgres via Supabase, Clerk for auth, Stripe for billing, cron routes at `/api/cron/*`). 2026-05 substrate-first turn confirmed: quiet strategy first, extract coordination as a reusable pill (`@devplane/coordination-core`, 8-phase plan filed at `docs/COORDINATION-PILL-EXTRACTION.md`; E-1 + E-2 shipped — audit-log + rate-limit migrated into the no-outside-imports `src/coordination/` boundary), operator dashboard becomes the reference expression, product emerges later. Pattern-propagation stack shipped 2026-05-17 (DP-156/157/158/159/160): `dp patterns` CLI + `devplane_patterns_search` / `devplane_patterns_get` MCP tools + MASTER-PATTERNS.md reconciliation. Portfolio Brief Protocol shipped 2026-05-20 end-to-end (per-project briefs sync from sister repos, surface on PA-site's `/portfolio/[slug]` detail pages and home cards). Portfolio reconciliation 2026-05-21: `~/.devplane/portfolio.json` now tracks 19 entries (was 15) — 1 hub, 3 tools, 6 expressions, 9 archives. Pattern library ships ~20 reusable patterns; capability doctrine is the architectural framework for everything built going forward.