ShipWithAI — an AI-native delivery studio

Positioning (the why). In the old world a company is its people — they hold the knowledge, make the calls, do the work. In the new world people move up to strategy, taste and judgment, agents do the labor, and the company becomes a shared, legible context layer — the brief, the brand, the conventions, the playbooks, the decision logs — that both plug into. ShipWithAI is built exactly like that, and the moat is legibility: a delivery operation documented so well that agents can run it. (Don't position it as "a terminal tool" — the operator has the terminal; the customer gets a fleet running on a legible context layer.)

What it is (the how). A fleet of specialist AI agents that run inside Claude Code, on an open context layer (its plugins, skills and conventions), to design, build, deploy, grow and monitor real products — e-commerce builds, SEO, marketing campaigns, marketing videos, 24/7 monitoring (and smart-contract audits). Humans direct and review; agents execute. Packaged as Claude Code plugins, runs locally; billed per engagement (no automated payments). We point it at the goldmine: work repetitive enough to systematize, complex enough that agencies are still slow and expensive.

Brand: ShipWithAI (no dot). Domain: shipwithai.nl. Full positioning → the positioning-ai-native-studio memory.

History. This repo was previously a hosted multi-agent web SaaS (a Next.js app + a bespoke agent runtime + Firestore + Stripe/x402 payment rails). That system was retired in the 2026-06 pivot to local-first; the old apps/web, packages/core, agents/, scripts/, memory/, and monorepo scaffolding were removed (recoverable from git history). The agent prompts and audit methodologies — the real IP — were ported into the plugins below.

Structure

.claude-plugin/marketplace.json   # local plugin marketplace (relative string sources, e.g. "./plugins/x" — loads from disk)
.claude/settings.json             # auto-activates the marketplace + plugins (tracked)
plugins/
  shipwithai-core/                # pm coordinator + /ship orchestrator + shared skills (intake, brand-extract)
  shipwithai-audit/               # /audit      — solidity-auditor + 3 methodologies + workflow
  shipwithai-web/                 # /ecommerce  — design/build/payments/deploy (Claude Design round-trip)
  shipwithai-growth/              # /seo /campaign — seo / marketing / tech-writer / ux-analyst
  shipwithai-video/               # /promo      — Remotion video + capture/compose skills + template
  shipwithai-monitor/             # /monitor    — 24/7 post-launch monitoring (tech/sales/traffic/seo/security/reputation) + alerts
docs/                             # production docs (e.g. promo-script.md)
site/                             # shipwithai.nl — static marketing site (no build; from the Claude Design "Aurora" template)
engagements/                      # per-client working dirs (gitignored; only index.json tracked)

How it works

• Plugins auto-activate. .claude/settings.json registers the local shipwithai marketplace (extraKnownMarketplaces) and enables all five plugins (enabledPlugins). On first open you accept a one-time trust/install prompt; then the commands are live — no /plugin typing. Fallback: /plugin marketplace add . then /plugin install.
• Each vertical is a wizard. Run its slash command (e.g. /shipwithai-audit:audit). The command runs the shared intake convention against its intake_questions: frontmatter (clickable choices + free-text), sets up engagements/<slug>/, runs the specialists, and produces the deliverable.
• Deliverables are files written into engagements/<slug>/ — reports, built sites, plans, MP4s. Specialists read/write the local working tree; there are no output tools or external persistence.
• The PM coordinates multi-agent verticals by delegating to specialist subagents (the Agent tool) one at a time, or via a bundled Workflow script for parallel/verified flows (the audit uses one).

The verticals

Key concepts

Plugin anatomy

A vertical plugin = commands/<name>.md (the wizard) + agents/*.md (subagents, with name/description/tools/model frontmatter) + skills/*/SKILL.md + optional workflows/*.js. shipwithai-core holds the pm agent and the shared intake + brand-extract skills every vertical reuses. There are 20 specialist agents and 12 skills across the plugins.

Intake wizard

Each command declares its questions in an intake_questions: YAML frontmatter block — the single source of truth (the local-first heir to the old use-cases.ts). The core intake skill reads that block: choices → AskUserQuestion (clickable), free-text asked conversationally, anything pre-filled from args is skipped. It emits a normalized brief the specialists act on.

Audit workflow

/audit at full depth runs plugins/shipwithai-audit/workflows/audit.js via the Workflow tool: Feynman + State-Inconsistency run once each as independent passes, then Nemesis runs fusion-only (its Phase-4 feedback loop over their combined output — it does NOT re-run the hunt passes), then every Critical/High/Medium finding is adversarially verified, then synthesized. quick/standard depths delegate to the solidity-auditor subagent directly. Gotcha: the Workflow runtime delivers the args global as a JSON string — workflow scripts must JSON.parse it (see audit.js).

Claude Design (code ↔ design — not Figma)

In shipwithai-web, design runs through Claude Design (claude.ai/design); authorize with /design-login. The claude-design skill has two paths. High-fidelity = design-sync ("Create using Claude Code"): bundle a standalone, Next-free, props-driven component library (tsup → dist/ + a tokens-driven styles.css) and sync it with the built-in /design-sync skill so the canvas designs with the studio's real components — run from the main session (it needs the DesignSync tool + approvals); a ui-designer subagent only shapes the package. Lighter = "Create here": push tokens.json + DESIGN.md + HTML mockups to a tracked design-sources/<brand>/ subfolder and import that. Either way the operator drives the canvas (human-in-the-loop, login-gated) and exports back to engagements/<slug>/design/claude-design-export/, which ui-developer builds from. Gotchas: components must own their backgrounds (a hero relying on the page body bg washes out in preview cards — set the canvas on html,body and on section components); the render check needs a node Chromium (~/Library/Caches/ms-playwright on macOS); never create a throwaway public repo (classifier-gated) — use a subfolder in an existing repo.

Marketing-video pipeline

shipwithai-video produces an MP4 with Remotion. capture-footage gathers real footage — branded HTML deliverables (via the bundled render-md.mjs) → Playwright screenshot (the Playwright MCP blocks file://, so serve over localhost), operator screen recordings (terminal, the Claude Design canvas, live storefronts), browser captures. remotion-compose copies the bundled data-driven template (plugins/shipwithai-video/template/), customizes src/brand.ts + src/scenes.ts, drops stills/clips into public/, and renders (npx remotion render). Scene types: title, message, grid, showcase (still), clip (screen recording via <OffthreadVideo trimBefore/trimAfter playbackRate>), stat (animated counters), cta. The current promo plan lives in docs/promo-script.md.

Full-pipeline orchestrator (/ship)

shipwithai-core ships a /ship command — the studio's conductor for an end-to-end product delivery. The pm agent drives it, running the verticals in sequence (decide → design → build → commerce → deploy → grow → promo → monitor), delegating to each vertical's agents/skills, threading one engagement dir through, and checkpointing with the operator at human-in-the-loop moments (the Claude Design canvas, before deploy). It's a guided pipeline, not autopilot; phases are skippable per product type; each vertical command still runs standalone. Deterministic stretches can be backed by a Workflow (like audit.js). /audit stays a standalone service, not a /ship phase. (Built; to be exercised on the next product round — the current promo build runs the verticals manually.)

Monitoring vertical (post-launch)

shipwithai-monitor runs after go-live. /monitor stands up a config (engagements/<slug>/monitoring/monitor.config.json) + a recurring scheduled cloud agent (cron, via the schedule skill) that calls /monitor --check <slug>. Each cycle (monitor-run skill) fans out the enabled specialists — uptime-sentinel (tech), revenue-analyst (sales/Stripe), traffic-analyst (visitors/analytics), seo-rank-watch (search), security-watch (deps/CVEs/headers), reputation-watch (brand) — each returning OK/WATCH/ALERT + numbers, then writes a dated digest + alerts and delivers them via the notify skill (push / Slack / email / Notion / file). Monitors are read-only (observe + report; a fix is a hand-off to the relevant build vertical), alert on change not steady-state, and degrade gracefully (unknown) when a source isn't connected.

Connected tools (MCP)

Playwright (browser/test/capture), Vercel (deploy), Stripe (payments), GitHub + Brave (repo/search) — all via globally-enabled Claude Code plugins; agents reference the mcp__* tools directly. No plugin-level .mcp.json is needed. Design does not use an MCP tool: it runs in Claude Design (claude.ai/design, a browser app) via the GitHub round-trip (the claude-design skill). The Figma MCP may still be present globally but the studio no longer depends on it.

Engagements

Per-client work lives in engagements/<owner>-<slug>-<YYYYMMDD>/. engagements/index.json is the tracked registry ({slug, vertical, date, status}); everything else under engagements/ is gitignored (client code is never committed). Mark status: complete when a deliverable ships.

Conventions when working here

• Build new work as plugin-shaped subagents / skills / commands / workflows — not as a node app.
• Agent tool lists use native tools + mcp__* patterns; no legacy tool names (no github_read_files, submit_deliverable, request_handoff, etc.).
• Deliverables are files in the engagement dir; don't reintroduce output tools, Firestore, or payment rails.
• The Remotion template self-installs per engagement (npm install inside the copied video/ dir). node + ffmpeg are available.
• To add a vertical: a new plugins/shipwithai-<name>/ with a commands/<name>.md wizard, its specialist agents, any skills, and an entry in marketplace.json + .claude/settings.json enabledPlugins.