From Conversation to Deployment

This is the most powerful way to use DevSpec. Brainstorm in a session, turn the decision into named action items, and explicitly ask an exact authorized agent to implement them. The agent reserves and claims the requested work, while your existing CI/CD pipeline deploys the resulting push.

How the loop works

DevSpec, coding agents, and your CI/CD pipeline work together without a work router. A current user request names the action items, either through a direct implementation surface or a canonical conversation command sent to an exact connection by its owner or an authorized delegate. The agent calls reserve_work_items for those ids, then claim_work_item one at a time, implements locally, and pushes according to project settings. CI/CD detects the push and deploys automatically.

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 provides coding-agent capacity on your local machine. Start it with named item ids or send an exact-target authorized command that names the work. The agent reserves exactly those ids, claims them one at a time, makes changes in a local worktree, and pushes according to your delivery settings. Presence or backlog discovery alone never authorizes implementation.

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 agent connection, then explicitly invoke named work (for example --items=ID1,ID2) or use DevSpec Send to address that exact connection.

Run multiple tasks in parallel

Autopilot never edits the directory you are working in. For each explicitly requested and claimed task, 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 happen inside that worktree, and the runner removes it once the item is reported. Your own checkout, including uncommitted work, is left untouched.

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

• Explicitly request compatible item sets from several exact connections. Each agent reserves and claims only its named work; dependency/conflict guards and atomic claims prevent duplicate holders.
• 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.