tanker

System design skill for complex multi-component projects. Produces a system diagram, component breakdown, API contracts, data model, and tech decisions before any code is written. Run /architect before /createplan on anything that spans more than one layer (frontend + backend, multiple services, or a new data model).

Creates a structured implementation plan document. Invoke after /explore Q&A is complete and all ambiguities are resolved. Produces a markdown plan with steps, subtasks, key decisions, and risks.

Curates the owner's reference library at ~/.claude/references/repos.yaml. Each entry is a GitHub repo you find inspiring — patterns to copy, products to study, stacks to learn from. The skill ingests the repo's signal files (README, manifests, schemas, docs) into the local 'refs' ChromaDB collection so /cto and github-scout pull from YOUR curated taste, not generic GitHub search. Idempotent — re-running on an existing entry is safe.

Generates an exhaustive product-facing PRD with screens, features, flows, landing page mock, and visual direction. This is the artifact the operator reviews BEFORE any code is written. Output is both narrative (prd.md) and visual (lightweight HTML wireframes for every screen + landing page). Run after /grill (and /benchmark if competitive) and before /architect. The prd-reviewer agent must PASS before the user is brought in for manual review.

Produces an exhaustive feature matrix for a competitive product category BEFORE any PRD is written. Rows = atomic features, columns = competitors + you, cells = yes/no/partial with evidence. Forces "does product X do feature Y?" instead of prose summaries where features slip through. Run this before /grill, /architect, or any PRD work on a competitive product. Replaces lazy prose teardowns.

YC-style forcing questions before writing any code. Six questions that reframe the product, challenge bad assumptions, and surface the 10-star version. Run this before /architect or /createplan on any new product or major feature. Stops you from building the wrong thing.

Injects a concise memory block into the project's CLAUDE.md so it auto-loads in every new CLI session. Solves the "fresh session blank slate" problem — run this at end of any session where important context was established. Also reads brain.md and context.md to brief you at the start of a session if the global CLAUDE.md rule hasn't already done so.

Complete release workflow — from working code to open PR. Syncs with main, runs tests, stages changes, pushes to remote, and opens a structured pull request. Run after /execute and /autoresearch-review when you're ready to ship. Replaces the ad-hoc "git push and hope" pattern.

Top-level autopilot orchestrator with human-in-the-loop gates. Turns a one-line product brief into a live, deployed product. Loads the brain + memory, runs github-scout for prior art, runs grill→/prd→architect→advisor decision gates, provisions infra in parallel (gh + supabase + vercel + railway via /vault-add credentials), dispatches engineering subagents in parallel for frontend/backend/data, gates merges with autoresearch-review + pre-merge agent, deploys preview→prod with auto-rollback, wires monitoring. Two HARD STOPS for human review: (1) post-PRD after prd-reviewer agent PASSes, (2) post-local-build after mvp-reviewer agent PASSes. State checkpointed every phase to outputs/<slug>/state.json so any session can resume. Default mode is autopilot with HITL gates — pass `--full-auto` to skip the human gates (not recommended for first run on a new product).

Research skill that finds best-in-class products in the category you're building, extracts what makes them exceptional, and produces a Reference Brief for use in /design-shotgun or static-site-replicator. The root cause of AI slop is building without a reference — this skill fixes that.

Data analyst skill. Takes a CSV / parquet / JSON / SQL endpoint + a question, produces a written answer with charts, backed by reproducible Python code that is actually executed (not just generated). ReAct loop over Plan → Execute → Reflect → Decide. Use for ad-hoc data exploration, KPI investigation, attribution analysis, return-rate cohort breakdowns, or any "look at this dataset and tell me what's interesting" question.

Indexes the local Obsidian vault at ~/Desktop/Obsidian/Brain/ into a local ChromaDB collection so /cto, /prd, /architect, and github-scout can do semantic retrieval (not keyword grep) against the owner's accumulated knowledge. Embeddings are computed locally via the default `all-MiniLM-L6-v2` model — vault contents never leave the machine. Incremental: only re-embeds chunks whose content changed. Run on demand or via the nightly Stop-hook.

Add or update a credential in the local tanker vault at ~/.claude/vault/credentials.json. Use when a provisioner subagent reports a missing key, or when the user wants to register a new service token. Reads the schema, prompts for the value securely, writes with 0600 perms, never logs the value.

Cross-model peer review. Takes an artifact (PRD, plan, code, spec, decision memo) and runs it past a DIFFERENT model than the one that authored it. Opus drafts → Sonnet or Haiku re-reads as an independent reader. Returns structured peer review — what's wrong, what's missing, what assumptions aren't defended, what to cut. Run before committing or sharing any single-model-authored artifact.

Deep pre-merge bug analysis skill. Takes a PR diff or branch and runs a systematic Karpathy-style autoresearch pass — enumerating failure modes by category, identifying untested edge cases, and scoring bug likelihood before anything ships.

Build backend APIs, servers, and databases. Covers Node/Express/Fastify, FastAPI, Supabase, auth patterns, error handling, and security. Trigger when the user needs a server, API endpoint, database schema, or backend integration.

Session recovery skill. Reads .claude/context.md and recent git history to reconstruct where the previous session left off. Run at the start of a new session on in-progress work to avoid re-reading the full conversation history.

Session checkpoint skill. Commits all in-progress work with a WIP prefix and writes a structured context file to .claude/context.md — capturing where you are, what's next, and what decisions were made. Run before ending a session on unfinished work so the next session can resume without re-reading the whole conversation.

Systematic debugging skill. Invoke when a bug exists but the cause is unknown. Traces failure from symptom to root cause using a structured elimination method — never guess-and-check.

Deployment skill covering Vercel, Railway, Fly.io, and Docker. Handles environment variable setup, CI/CD pipeline, health checks, and rollback strategy. Run after /execute when the build is ready to ship, or on a greenfield project to wire up deployment from the start.

Generates 4 distinct HTML/CSS design directions for the product you're building. Each is a fully working mini-prototype with a real palette, typography, and hero section — not a mockup image. You pick one direction, then it becomes the design specification for the full build. Breaks the "first generic output wins" problem.

Project brain skill. Writes, reads, and maintains a .claude/brain.md file in the current project — storing conventions, decisions, pitfalls, and preferences that accumulate across sessions. Run at the end of any meaningful work session, or whenever something important is learned. Also reads the brain at the start of /explore and /retro.

Post-ship observability skill. Sets up error tracking, analytics, uptime monitoring, and logging for a deployed project. Run after /deploy, or when something breaks in production and you realise you can't see what's happening.

Self-improvement skill. Auto-invoked when a step is blocked, something goes wrong during implementation, or the user gives corrective feedback ("no, don't do that", "that was wrong", "instead do X", "stop doing Y"). Traces the failure to the responsible skill/agent/rule file, proposes a surgical improvement, and applies it after approval. Also invoke manually with /reflect to capture a learning from the current session.

Weekly engineering retrospective for a project. Reads git history, the project brain, and asks what shipped, what broke, and what slowed things down. Produces a structured report and writes key learnings back to .claude/brain.md. Run at the end of a sprint or week of work.

Generates targeted tests for untested code paths. Invoke after /autoresearch-review surfaces test gaps, or directly on any function/module. Writes the minimum tests needed to catch the highest-probability bugs — not ceremonial coverage padding.

Build Chrome and Firefox browser extensions (Manifest V3). Trigger when the user says "build a browser extension", "chrome extension", "firefox addon", "extension that does X", or wants to add browser-level functionality (injecting into pages, intercepting requests, adding a toolbar button, modifying page content, reading clipboard, tab management, etc.). Outputs a ready-to-load unpacked extension folder. Covers the full lifecycle: design → build → self-test → security check → package.

Captures a bug, feature, or improvement as a clean, structured issue document. Invoke mid-flow when the user wants to log something without losing their current context.

Updates CHANGELOG.md and inline docs to reflect a recent code change. Invoke after implementing a feature or fix — describe what changed or paste the diff.

Enters execution mode to implement a plan step by step. Invoke with the plan file path or after /createplan is complete. Implements one step at a time, updates the plan tracker, and writes a status report after each step.

Enters teaching mode to explain a concept, pattern, or decision in the codebase. Invoke when the user wants to understand something rather than build it. Presents the topic in three progressive levels and pauses for confirmation between each.

Build mobile apps usable on iPhone and Android. Trigger when the user says "build a mobile app", "make this work on my phone", "I want an app I can use on mobile", "PWA", "React Native", or "Expo". Chooses the right path based on requirements: PWA (fastest, no install needed, builds on web skills) or Expo/React Native (native device APIs, app store distribution). Always clarifies the path before building.

Triages findings from a peer code reviewer. Invoke when a colleague or reviewer has submitted feedback — classifies each finding as Accept, Accept with wrong fix, Context Missing, or Reject, then produces an action plan.

Replicate any reference website as a polished static HTML/CSS/JS site with new brand assets. Trigger when the user shares a reference website URL and wants a new site built from it, says "build me a site like X", "replicate this website", "make a static site based on this design", or wants any multi-section informational/listing/marketing website — with or without a reference. This skill manages the full build lifecycle: gather → build → eval → refine → deliver.