From Conversation to Deployment

This is the most powerful way to use DevSpec. Once this loop is in place, you can brainstorm a feature in a session, and by the time you are done talking, Autopilot is already implementing it. Your changes deploy automatically. You never leave the conversation.

How the loop works

DevSpec, Autopilot, and your CI/CD pipeline work together as a single system. You talk to Dev in a session. Dev creates action items and queues them for Autopilot. Autopilot runs locally on your machine, picks up the items, makes the code changes, and pushes to your deployment branch. Your CI/CD pipeline detects the push and deploys automatically. You see the result live.

1. Create your deployment branch

Create a dedicated branch in your repository for DevSpec to push to. Call it anything — devspec-staging, autopilot, or preview. This is the branch Autopilot will push to, and the branch your CI/CD pipeline will watch.

Example

git checkout -b devspec-staging
git push -u origin devspec-staging

Use a branch you are comfortable with code appearing on automatically. Do not use main or production.

2. Connect this branch in DevSpec

In your project settings, go to Repository and set the active branch to the one you just created. This is critical — DevSpec reads your codebase from this branch. If Dev is answering questions about code and Autopilot is pushing to a different branch, your answers will drift from reality. Keep them in sync.

DevSpec answers questions based on the branch it is pointed at. Autopilot pushes to the same branch. Keeping them aligned is the single most important configuration step.

3. Set up CI/CD on that branch

Configure your deployment platform to trigger a deployment whenever your DevSpec branch receives a push. This is a one-time setup. After this, every Autopilot push automatically triggers a deploy.

Vercel

# In your Vercel project settings:
# Production Branch → devspec-staging
# Or add it as a Preview Branch with auto-deploy enabled

Netlify

# In netlify.toml:
[build]
  publish = "out"

[[context.devspec-staging]]
  command = "npm run build"

GitHub Actions

on:
  push:
    branches:
      - devspec-staging

Coolify

# In Coolify → your application → Source:
# Set the deployed branch to devspec-staging and enable
# "Automatic Deployment" so Coolify redeploys on every push.

4. Install and configure Autopilot

Autopilot is a Claude Code plugin that runs on your local machine. It polls DevSpec for queued action items, claims them, makes the changes in a local worktree, and pushes the result to your deployment branch.

Installation

• Install Claude Code if you have not already.
• Add the DevSpec MCP server to your Claude Code config using your project API key.
• Set your target branch to match the branch you created in step 1.
• Start the Autopilot heartbeat. It will begin polling for work immediately.

Run multiple tasks in parallel

Autopilot never edits the directory you are working in. For each task it picks up, a persistent runner creates an isolated git worktree — a separate working copy of your repository that shares the same Git history but lives in its own folder. The changes, tests, and commit all happen inside that worktree, and the runner removes it once the item is reported. Your own checkout, including any uncommitted work, is left completely untouched.

Because every task gets its own worktree, you can run more than one task at the same time without them clashing:

• Run several runners on one machine (or across machines), and each claims a different item from the ordered queue. Two runners never grab work that overlaps, so their worktrees never collide.
• Keep coding in your main checkout while Autopilot works in the background — its worktrees are separate, so nothing overwrites the files you have open.

Worktree isolation is how runners (Claude Code, Antigravity, and others that use worktrees) stay out of your way. See the Autopilot Setup Guide for per-runner details.