just-ship

Neues Projekt im aktuellen Workspace verknüpfen — nur Projekt-ID in project.json schreiben

Board-Verbindung einrichten — via jsp_ Token oder Status prüfen

/just-ship-review — Branch lokal auschecken, builden, Dev-Server starten und testen

Just Ship installieren und Projekt konfigurieren — Stack erkennen, project.json befüllen, Board verbinden

Spike-Ergebnis reviewen — Zusammenfassung anzeigen, Follow-Up-Tickets erstellen, Spike-Ticket abschliessen

Single source of truth for how the just-ship pipeline talks to the CEO. Defines the voice (Result-First, tables for lists of 3+, status icons, short active sentences, no inner monologue) and the five Core Templates (develop-complete, ship-complete, ticket-created, epic-created, phase-progress). Every user-facing output string produced by an agent, a skill, or a pipeline phase runs through this skill — never freeform prose. Triggers at the end of /develop, at the end of /ship, in Sidekick replies for ticket/epic creation, in /just-ship-status, and during phase-progress updates. Load whenever you are about to render a terminal block the CEO will read.

The operating system for decision-making in this team. ALWAYS load this skill. It defines what the human decides and what the AI expert team decides autonomously. Use on EVERY task, EVERY conversation, EVERY feature. This skill prevents the anti-pattern of asking the user technical, design, or implementation questions that an expert should answer. It is the single most important skill in the stack — without it, every other skill's quality is bottlenecked by the user being asked questions they shouldn't answer. Triggers on: literally everything. This is not optional. Load it first, always.

Use when implementing API endpoints, server-side business logic, webhook handlers, event pipelines, shared hooks, or backend integrations. Also triggers for queue-based processing, background jobs, third-party API integrations, or any server-side data flow. This skill builds production-grade backend code — not just working code, but code that handles failure, observes itself, and stays reliable at 3am. Use proactively on every backend task, even simple CRUD endpoints — because every endpoint eventually becomes critical.

You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.

Use when creating new UIs from scratch — landing pages, marketing sites, prototypes, or any greenfield frontend work where no existing design system applies. Also triggers for portfolio sites, product launches, campaign pages, microsites, or any page where visual distinction and memorability matter as much as function. This skill creates something genuinely distinctive — not another AI-generated template. For spacing, typography defaults, responsive strategy, and accessibility, defer to `frontend-design`. This skill adds the creative layer on top.

Use when making database schema changes, writing migrations, configuring RLS policies, syncing TypeScript types, or designing data models from scratch. Also triggers for query performance issues, indexing strategy, data modeling decisions (normalize vs. denormalize, ledger vs. counter, lookup table vs. enum), and any Supabase/Postgres architecture question. This skill doesn't just write migrations — it architects data models that stay correct, fast, and secure as the product scales. Use proactively whenever data storage is involved, even for "simple" tables.

Your Head of Design + Head of Product-UX. Use this skill whenever a decision is strategic — product structure, interaction philosophy, design-system direction, cross-feature consistency, or any "how should this feel across the product" question. Triggers on: product structure ("is this projekt-zentrisch or status-zentrisch?"), interaction philosophy ("click-to-expand or inline-edit across the app?"), design-system direction ("when do we use a sheet vs a page?"), consistency reviews across features, naming conventions for product concepts, whether a new pattern belongs in the system or is a one-off, and strategic UX calls that span multiple screens. Think of this as the Karri Saarinen (Linear) / Noah Levin (Figma) / Evil Rabbit (Vercel) lens — Design Leadership on equal footing with Technical Leadership. Peer to `product-cto`. Use proactively whenever a decision reaches beyond one screen or one component, even if the user does not explicitly say "strategic" — cross-product design is the job description, not an

Nächstes ready_to_develop Ticket holen und autonom implementieren

Board-Verbindung entfernen — zurück zu CLI-only

Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies

Use when you have a written implementation plan to execute in a separate session with review checkpoints

Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.

Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup

Use when building any user-facing UI — components, pages, layouts, forms, tables, dashboards, or any feature where visual quality matters. Also triggers for responsive implementation, animation/transitions, design system work, component composition, and design decision-making. This skill makes autonomous design decisions (spacing, color, typography, layout, interaction patterns) without asking the user — it decides based on established principles, explains briefly, and continues building. Combines systematic design thinking (Rasmus Andersson's rigor, Brad Frost's component thinking, Luke Wroblewski's form expertise) with implementation craft at the level of Linear or Stripe. Use proactively on every frontend task, even "simple" ones.

Implementiere was gerade besprochen wurde — ohne Ticket, mit vollem Agent-Workflow

Projekt-Setup \u2014 project.json erstellen, Stack erkennen, CLAUDE.md generieren

/just-ship-status — Lokalen Repo-Zustand anzeigen (Branches, PRs, Board, Worktrees)

CLAUDE.md und project.json gegen aktuelle Framework-Templates abgleichen und ergänzen

VPS verwalten — Status pruefen, Projekte verbinden, neuen VPS einrichten

Scans third-party plugin skills for prompt injection, credential harvesting, exfiltration, and supply chain risks before installation. Run automatically during setup.sh plugin install or manually via /just-ship-audit --skills plugin-security-gate.

Your technical co-founder with obsessive product taste. Use this skill whenever building features, reviewing architecture, planning new products, enriching tickets with craft requirements, or evaluating technical decisions. Triggers on: building any user-facing feature, reviewing code or architecture, "how should we build this", "review this", "make this production-ready", "what's missing", planning technical architecture, discussing performance/monitoring/logging/resilience, or when the user shares a feature idea and wants it built right. Also triggers when refining tickets, specs, or PRDs to add the technical craft layer. Think of this as the Karri Saarinen / Guillermo Rauch lens — every feature should be built like Linear or Vercel would build it. Use this skill proactively whenever a build task comes in, even if the user doesn't explicitly ask for "product quality" — excellence should be the default, not an add-on.

Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation

Stuck-Ticket recovern — Resume bei vorhandenem Code, Restart bei leerem Worktree

Use when completing tasks, implementing major features, or before merging to verify work meets requirements

Alles abschliessen — commit, push, PR, merge, zurück auf main. Vollständig autonom, NULL Rückfragen. Unterstützt /ship T-{N} für direkten Branch-Zugriff.

Run a short Sidekick conversation that shapes a fuzzy idea into a concrete artifact (ticket, epic, or spike) in at most 3 turns, using only business-level questions.

Strategic sparring partner for thinking through ideas, features, and decisions. Use when the CEO wants to discuss, explore, or think through a topic — NOT when they want to build something (that's brainstorming). Triggers on: "lass uns besprechen", "was denkst du", "ich bin unsicher", "wie würdest du", "sollen wir", "ich hab da eine Idee", "was hältst du von", "strategisch betrachten", "lass uns durchdenken", "discuss", "think through", "what do you think about". This skill loads the right domain experts automatically based on the topic, conducts a structured discussion, and exits cleanly — either as a resolved discussion or as a ticket via /ticket.

Use when executing implementation plans with independent tasks in the current session

Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes

Use when implementing any feature or bugfix, before writing implementation code

Ticket schreiben — Bug, Feature, Improvement oder Spike als strukturiertes Ticket erfassen. Unterstützt auch Splitting (Epic + Children) und manuelles Gruppieren.

Write high-quality product tickets — user stories, bugs, improvements, spikes, and technical debt items. Use this skill whenever the user wants to create, refine, split, or review a ticket for any project management tool (Notion, Linear, Jira, GitHub Issues, or plain Markdown). Triggers on phrases like "write a ticket", "create a story", "document this bug", "formulate a ticket for...", "this ticket is too big", or when the user shares rough requirements, bug reports, or feature ideas that need structuring. Also triggers when the user asks to review or improve an existing ticket. Always use this skill before writing tickets to ensure consistent, PM-quality structure — never include implementation details, code, or architecture decisions in tickets.

Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification

Use when planning a feature from a UI/UX perspective — user flows, screen inventory, information architecture, navigation, and interaction patterns. Use BEFORE implementation, AFTER brainstorming. Also triggers for navigation redesign, onboarding flow design, mobile-first planning, feature scoping from a UX perspective, or when a ticket reads like a feature description rather than a scoped task. This skill makes autonomous UX decisions — it doesn't ask "modal or bottom sheet?" when the answer is obvious from the context. It applies UX heuristics, accessibility, and mobile-native patterns by default, not as an afterthought. Use proactively whenever a feature needs UX definition before code.

Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always