SpeziVibe

KO | EN

gitlite — search

#javascript #react #typescript #llm #golang #machine-learning #rust #docker #nodejs #cli #kubernetes #awesome-list #security #openai

(★ 22)

AI-enabled toolkit for building cross-platform digital health apps

SpeziVibe Latest Version Download

Download Latest Version (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

<h1 align="center">SpeziVibe</h1>

<p align="center">
  <strong>Installable skills for building digital health software with AI coding tools.</strong>
</p>

---

Spezi Vibe packages reusable product, clinical, regulatory, interoperability, and platform guidance into skills that can be installed in minutes and used directly in real projects.

This work supports the broader [Stanford Spezi](https://github.com/StanfordSpezi) mission of lowering the barrier to building thoughtful, high-quality digital health experiences.

## Quick Start

Install all skills into your coding agent with a single command:

```bash
npx skills add StanfordSpezi/SpeziVibe --all
```

Or list them first to see what is available:

```bash
npx skills add StanfordSpezi/SpeziVibe --list
```

> **Need `npx`?** Install [Node.js](https://nodejs.org/) — `npm` and `npx` are included. Then confirm with `node -v && npx -v`.

### Manual Install

If you prefer not to use `npx`, download the latest `spezivibe-skills.zip` from [Releases](https://github.com/StanfordSpezi/SpeziVibe/releases), unzip it, and copy the skill folders into your coding tool's skills directory (e.g., `.claude/skills/` for Claude Code).

## New To Vibe Coding?

Vibe coding is a practical way of building software with an AI coding partner. Instead of starting from a blank page, you work in natural language: you describe the app, workflow, research plan, or technical constraint, and the agent helps you explore the codebase, make changes, draft plans, and explain tradeoffs.

If you are just getting started, these tools are a good place to begin:

- [Claude Code](https://docs.anthropic.com/en/docs/claude-code/getting-started) for terminal-based AI coding workflows
- [OpenAI Codex](https://openai.com/codex/) for agentic software engineering with skills support
- [Gemini CLI](https://github.com/google-gemini/gemini-cli) for an open-source terminal coding agent

If you prefer a more guided starting point, Claude and Codex also have desktop app experiences in addition to CLI workflows. A practical way to begin is:

1. choose a coding tool such as Claude, Codex, or another supported agent
2. choose whether you want to work in a desktop app or in the CLI
3. create or sign in to your account and then follow the instructions below to install `npx` and the Spezi Vibe skills

### Install `npx`

The easiest way to get `npx` is to install [Node.js](https://nodejs.org/). `npm` and `npx` are included with standard Node.js installations.

1. Install a current Node.js release from [nodejs.org](https://nodejs.org/).
2. Confirm the tools are available:

```bash
node -v
npm -v
npx -v
```

3. Use `npx skills` to install Spezi Vibe into your coding agent.

### Install Skills

We use the [skills](https://github.com/vercel-labs/skills) tool for installing and sharing reusable skills across supported agents.

Install every skill from this repository:

```bash
npx skills add StanfordSpezi/SpeziVibe --all
```

If you want to target a specific agent, add `-a claude-code`, `-a codex`, or another supported agent:

```bash
npx skills add StanfordSpezi/SpeziVibe --skill '*' -a claude-code
```

## Where To Start

The fastest way to get started is to run `build-an-app`. Describe what you want to build and it figures out which planning skills you need, runs them in order, and hands the implementation plan off to your AI coding agent for the actual build. You do not need to know the individual skills or their order — the orchestrator handles that for you.

If you prefer to run skills individually, here is the process they follow. Plan first; clone a Spezi template only when the plan is ready and you're set to build. Not every project needs every skill — use what fits.

### 1. Define the Need

Understand the clinical or operational problem before deciding on a product. Investigate the problem space, identify affected stakeholders, and refine a need statement until it is specific, evidence-grounded, and free of embedded solutions.

Use: `biodesign-needs-finding`

### 2. Plan the Product

Design the user experience, data model, and compliance posture. Run whichever skills are relevant — not all are required for every project.

- `digital-health-ux-planning` — user journeys, onboarding, engagement, and day-to-day workflows
- `health-data-model-planning` — core entities, relationships, and FHIR-oriented data structures
- `fhir-data-model-design` — map clinical concepts into interoperable FHIR resources and terminology
- `digital-health-compliance-planning` — privacy, regulatory, and governance expectations
- `digital-health-study-planning` — study protocol, consent, and data collection (only if tied to a research study)

Each skill writes a brief to `docs/planning/` in your working directory.

### 3. Plan the Build

Feed your planning outputs into `app-build-planner` to get a sequenced implementation plan. The output is `docs/implementation-plan.md` — milestones, tasks, dependencies, and verification criteria.

Use: `app-build-planner`

### 4. Choose a Platform and Clone the Template (optional)

Once the plan is in hand, decide whether the project is better suited to React Native or Apple-native, then clone the matching Spezi starter template. This skill uses your planning briefs to inform the recommendation, clones the template, and moves your `docs/planning/` and `docs/implementation-plan.md` into the cloned repo.

Use: `spezi-platform-selection`

> **Skip this if you're not using a Spezi template.** The planning briefs and implementation plan work in any codebase — a blank Expo project, an existing repo, a different framework. Hand them to your coding agent directly and ask it to build Milestone 1.

### 5. Build the App

Ask your AI coding agent to implement Milestone 1 from `docs/implementation-plan.md`. The agent uses your planning briefs as context and the Spezi template's patterns as scaffolding (or your own codebase if you skipped step 4). Build each milestone, verify, then move to the next.

### 6. Keep Learning (Optional)

Set up a project wiki to accumulate knowledge as you build. Every interview, paper, clinical observation, and competitive finding gets ingested into a persistent, AI-maintained knowledge base that compounds over the life of the project. Planning documents from earlier steps seed the wiki automatically.

Use: `project-wiki`

## Skill Catalog

This repository is organized for `npx skills`, with one skill per folder under `skills/`.

Listed in the order they typically run.

| Skill | What it does |
|-------|-------------|
| `build-an-app` | Walk through the full process — from idea to running code |
| `biodesign-needs-finding` | Turn an idea into a real clinical need |
| `digital-health-ux-planning` | Design a patient- and clinician-friendly experience |
| `digital-health-study-planning` | Plan a study around the app |
| `digital-health-compliance-planning` | Think through privacy and regulatory risk early |
| `health-data-model-planning` | Shape the app's health data backbone |
| `fhir-data-model-design` | Map clinical concepts to FHIR |
| `app-build-planner` | Turn planning outputs into a milestone-based build plan |
| `spezi-platform-selection` | Choose React Native or Apple-native and clone the matching Spezi starter template (optional) |
| `fasten-ehr-integration` | Pull patients' real EHR records into the app via Fasten Connect, with a built-in privacy walkthrough |
| `project-wiki` | Turn your project into a compounding, AI-maintained knowledge base |
| `keep-a-changelog-generator` | Draft changelogs people can actually read |
| `release-notes-generator` | Summarize a release clearly |

### `build-an-app`

Walk through the full process of building a digital health app — describe what you want to build and it figures out which planning skills you need, runs them in order, and hands off to implementation. Start here if you are unsure where to begin.