The landing surface — the project's entire workflow is the second pill: git push origin main.

GitSlip

A zero-config GitHub-to-Cloudflare-Pages deployment service for people writing code with AI from a laptop, an iPad, or a phone — push to GitHub, get a live URL.

Status. Live at gitslip.com — single-tenant, MIT-licensed, no paid tier. Open for sign-ups, free for the foreseeable future. Custom-domain support is intentionally limited (see Limitations below).

"You made something. Now you want to see it."

GitSlip watches your GitHub repos. When you push, it builds and deploys to Cloudflare Pages automatically. No setup per repo. No build commands to memorize. Just push and watch the URL appear.

Built for vibe coding from your phone. AI writes the code, GitHub gets the push, you tap the link. No laptop required.

Choose your path

• See it work → the 30-second trailer below, or open gitslip.com and sign up
• Use it → How it works — connect a repo, push, get a URL
• Self-host it → Self-hosting — full setup on your own Cloudflare account
• Understand the system → ARCHITECTURE.md (the why) and INFRASTRUCTURE.md (the what)
• Read the worldview → UX.md — why the magic moment matters more than the deploy pipeline
• Contribute or use an AI agent → AGENTS.md (ghostwriter code standards) and CONTRIBUTING.md

What this is not

• Not a Vercel or Netlify replacement for production traffic. Cloudflare Pages has its own free-tier limits. Real product sites with significant traffic should use a real plan, somewhere.
• Not a hosting provider. Your sites live on Cloudflare's edge — GitSlip is the workflow that gets them there. If Cloudflare goes down, your sites go down.
• Not a build platform for server-rendered Next.js. Cloudflare Pages runs at the edge, not Node.js. Static export works; SSR / API routes / Node middleware do not.
• Not a CI/CD system. No test runs, no preview gates, no environment promotion ladder. Push to main, see it live. That's the whole shape.
• Not "free forever." Cloudflare has free-tier limits on build minutes and bandwidth. Most hobbyists never hit them; people pushing every five minutes will.

How it works

1. Login with GitHub One click. You're in.

2. Install the GitSlip App Pick which repos to watch. All of them, or just a few.

3. Push code That's it. Your site goes live. Every push after this just works.

The first time takes about two minutes. After that, you never think about deployment again.

What gets built

GitSlip looks at your code and figures out how to build it:

• Next.js — works with static export. Server components and API routes won't work on Cloudflare Pages.
• Vite — React, Vue, Svelte, whatever. If Vite builds it, GitSlip deploys it.
• Astro — static and hybrid modes both work.
• Static HTML — just HTML/CSS/JS files? Those work too.

Framework detection happens automatically by checking your package.json.

Trailer

The 50-second push-to-live loop, in motion. Dashboard → terminal → build → live URL → mobile.

trailer.mp4

Self-hosting

GitSlip runs on Cloudflare Workers. If you want your own instance, here's what you need.

Prerequisites

• A Cloudflare account (free tier works)
• A GitHub account
• Node.js 18+

GitHub integration architecture

GitSlip requires two separate GitHub integrations. This is a common pattern but can be confusing:

Integration	Purpose	Location
OAuth App	User login ("Continue with GitHub")	GitHub Settings → Developer Settings → OAuth Apps
GitHub App	Webhooks, repo access, installations	GitHub Settings → Developer Settings → GitHub Apps

Why two apps? OAuth Apps handle user authentication only. GitHub Apps handle everything else: receiving webhooks, accessing repo contents, posting commit statuses. They use different credential types and have separate settings pages on GitHub.

Create a GitHub OAuth App

1. Go to GitHub Settings → Developer Settings → OAuth Apps
2. Create new OAuth App:
   • Homepage URL: https://your-domain.com
   • Callback URL: https://your-domain.com/auth/github/callback
3. Note the Client ID (starts with Ov23li...)
4. Generate a Client Secret and save it securely

Create a GitHub App

1. Go to GitHub Settings → Developer Settings → GitHub Apps
2. Create new GitHub App:
   • Homepage URL: https://your-domain.com
   • Webhook URL: https://your-domain.com/webhook/github
   • Webhook secret: Generate a random string
   • Permissions:
     • Repository: Contents (Read), Commit statuses (Read & Write)
     • Account: Email addresses (Read)
   • Subscribe to events: Push, Installation
3. Generate a private key (downloads as .pem)
4. Note the App ID (a number like 2671603)

Environment variables

Public variables (in wrangler.toml):

[vars]
GITHUB_CLIENT_ID = "Ov23li..."   # OAuth App Client ID (NOT GitHub App)
GITHUB_APP_ID = "2671603"        # GitHub App ID (a number)

Frontend build-time (in .env or your build environment):

Variable	Default	Purpose
VITE_GITSLIP_DOMAIN	gitslip.com	Brands the frontend (titles, vanity URL examples, etc.)

Forks and self-hosters should set VITE_GITSLIP_DOMAIN to their own domain before running pnpm build. See .env.example for the full list.

Secrets (via wrangler secret put, never in git):

Secret	Source	Purpose
GITHUB_CLIENT_SECRET	OAuth App	Token exchange during login
GITHUB_APP_PRIVATE_KEY	GitHub App	Signing installation tokens
GITHUB_WEBHOOK_SECRET	GitHub App	Webhook signature verification
ENCRYPTION_KEY	Generate yourself	32-byte hex for encrypting stored tokens
CF_API_TOKEN	Cloudflare dashboard	API token with Pages:Edit permission
CF_ACCOUNT_ID	Cloudflare dashboard	Your Cloudflare account ID
GITSLIP_API_KEY	Generate yourself	Build server authentication

Common mistake: Using the GitHub App's client secret instead of the OAuth App's. They look similar but are for different apps. If login fails with "client_id and/or client_secret incorrect", verify GITHUB_CLIENT_SECRET came from the OAuth App settings page.

Local development

# Install dependencies
pnpm install
cd frontend && pnpm install && cd ..

# Create .dev.vars with secrets (see below)
# Run both backend and frontend
pnpm dev

This starts:

• Backend (blue): Hono API on localhost:8787 ← Use this URL for testing
• Frontend (green): Vite dev server on localhost:3000 (for hot reload)

Important: For OAuth login testing, go to http://localhost:8787. The frontend dev server on port 3000 is for hot-reload during UI development, but OAuth callbacks are configured for port 8787.

You can also run them separately:

• pnpm dev:api - Backend only
• pnpm dev:web - Frontend only

Local OAuth App (required for local development)

GitHub OAuth Apps have a single callback URL. Production uses https://your-domain.com/auth/github/callback, but local dev needs http://localhost:8787/auth/github/callback. You need two OAuth Apps:

OAuth App	Callback URL	Used For
GitSlip	https://your-domain.com/auth/github/callback	Production
GitSlip (Local)	http://localhost:8787/auth/github/callback	Local development

To create the local OAuth App:

1. Go to GitHub Settings → Developer Settings → OAuth Apps
2. Create new OAuth App named "GitSlip (Local)"
3. Homepage URL: http://localhost:8787
4. Callback URL: http://localhost:8787/auth/github/callback
5. Copy the Client ID and generate a Client Secret
6. Add these to your .dev.vars file (see below)

Local secrets (.dev.vars)

Create a .dev.vars file in the project root (this file is gitignored):

# Local OAuth App credentials (from "GitSlip (Local)" OAuth App)
# NOTE: These are DIFFERENT from production credentials
GITHUB_CLIENT_ID=your-local-oauth-client-id
GITHUB_CLIENT_SECRET=your-local-oauth-client-secret

# GitHub App credentials (for webhooks/repo access - same as production)
GITHUB_APP_PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----
...your private key contents...
-----END RSA PRIVATE KEY-----"
GITHUB_WEBHOOK_SECRET=your-webhook-secret

# Other secrets
ENCRYPTION_KEY=your-32-byte-hex-string
CF_API_TOKEN=your-cloudflare-api-token
CF_ACCOUNT_ID=your-cloudflare-account-id
GITSLIP_API_KEY=your-build-server-api-key

Deploy

# Create D1 database
wrangler d1 create gitslip-db

# Update wrangler.toml with the database ID from the output

# Run migrations
wrangler d1 execute gitslip-db --file=./schema.sql

# Build frontend and deploy Worker with static assets
pnpm build
wrangler deploy

The Worker serves both the API and the React SPA. Static assets are bundled via [assets] in wrangler.toml.

How it works (technical)

Push to GitHub
     │
     ▼
GitHub sends webhook to GitSlip Worker
     │
     ▼
Worker creates deployment with status 'queued' in D1
     │
     ▼
Build server polls for pending jobs
     │
     ▼
Build server clones repo, runs npm install & build
     │
     ▼
Build server deploys to Cloudflare Pages
     │
     ▼
Posts commit status with live URL

The backend runs on Cloudflare Workers with D1 (database) and KV (sessions). A dedicated build server handles cloning and building repos. The frontend is a React SPA deployed alongside the Worker as static assets.

Build server

GitSlip uses a Hetzner VM to process builds. The build server:

• Polls the Worker API every 5 seconds for pending jobs
• Claims jobs atomically (prevents race conditions)
• Clones repos using GitHub installation tokens
• Runs framework-appropriate build commands
• Deploys to Cloudflare Pages via wrangler

Build server API authentication. All build API endpoints require the X-GitSlip-API-Key header:

curl -H "X-GitSlip-API-Key: YOUR_KEY" \
  https://your-worker.workers.dev/api/builds/pending

For detailed infrastructure documentation, see INFRASTRUCTURE.md.

Limitations

Worth knowing before you start:

• Next.js is limited. Cloudflare Pages runs at the edge, not Node.js. Server components, API routes, and middleware that need Node.js won't work. Static export is your friend.

• All infrastructure is managed. GitSlip handles all deployment infrastructure. No Cloudflare account needed.

• Free tier limits. Cloudflare's free plan has build limits. If you're pushing constantly, you might hit them. Most people never do.

• Custom domains are limited. Your sites get a vanity URL like myapp.gitslip.com. Full custom domains are planned, not built.

AI tool integration

GitSlip posts preview URLs to GitHub commit statuses after each deploy. But if you're vibe coding with AI tools (Claude Code, Cursor, etc.), you might miss these notifications.

Solution: Add a snippet to your project's AI instruction file. The AI will remind you of your preview URL after every push.

Vanity URLs

Every repo gets a vanity URL based on its name:

• https://my-app.gitslip.com → Main branch
• https://my-app--swift-cloud.gitslip.com → Feature branches (word pairs coming soon)

For Claude Code (CLAUDE.md)

Add this to .claude/CLAUDE.md in your repo:

## GitSlip preview URLs

This project uses GitSlip for automatic preview deployments.

After pushing changes to git:

1. Preview URL: https://{your-subdomain}.gitslip.com
2. Changes go live in ~30-60 seconds

Always remind the user of their preview URL after pushing.

Replace {your-subdomain} with your repo's subdomain (visible in the GitSlip dashboard).

For Cursor (.cursorrules)

Add this to .cursorrules in your repo:

## GitSlip integration

When pushing code to this repository, remind the user:

- Preview URL: https://{your-subdomain}.gitslip.com
- Changes deploy in ~30-60 seconds

For any AI tool (.gitslip)

Add a .gitslip file in your repo root:

{
  "version": 1,
  "preview_url": "https://{your-subdomain}.gitslip.com",
  "build_time": "30-60 seconds",
  "ai_hint": "After pushing changes to git, remind the user that their preview will be live at the preview_url above."
}

AI tools that read project files will pick this up automatically.

Contributing

See CONTRIBUTING.md for development setup and code style.

Security

Found a vulnerability? See SECURITY.md.

License

GitSlip is licensed under the MIT License.

---

You made something. Go see it live.

gitslip.com