How to Install and Configure Continue Dev CLI for Local Development

The Continue Dev CLI streamlines local development by automating environment setup, code generation, and testing, letting you focus on building features faster. This guide covers installing the CLI, configuring it for your stack, and seeing it in action on a real project.

Why Continue Dev CLI Is a Game‑Changer for Local Development

Typical frustrations with manual environment configuration

Install node@14, python@3.9, docker, and psql on the host machine.
Clone multiple repositories, each with its own README.md describing a different set of environment variables.
Copy .env.example files, rename them, and manually replace placeholder values with secrets pulled from a vault.
Spin up Docker Compose, then run database migrations against a remote staging cluster because the local DB image was out of sync.
Start several processes with npm run dev, uvicorn, and docker compose up, watching the logs for race conditions.

Version drift. Different teammates use different Node or Python versions, causing subtle bugs that appear only after a merge.
Secret sprawl. Environment files are scattered across services; a missing key results in runtime errors that are hard to trace.
Manual orchestration. Coordinating container startup, migration scripts, and hot‑reload servers is error‑prone.
Documentation rot. As the stack evolves, “how‑to‑run‑locally” sections in READMEs fall behind, leaving new hires guessing.

Even after standardizing on asdf for version management and adding a docker-compose.override.yml for local development, the process still required a series of explicit steps. A missing .env key in a worker service caused a MODULE_NOT_FOUND error that could have been caught automatically.

How Continue Dev CLI solves those pain points

Declarative environment manifests. A continue.yml file lives at the root of the monorepo and describes every service, its runtime, and required variables.
Self‑healing orchestration. The CLI parses the manifest, resolves toolchains via asdf (or its own shim layer), fetches secrets from a configured vault, and runs a dependency graph that guarantees containers are ready before the code starts.

services:
  api:
    runtime: node@18
    command: npm run dev
    env:
      - DATABASE_URL=${secrets:postgres_url}
      - JWT_SECRET=${secrets:jwt_secret}
    ports:
      - 3000:3000
  worker:
    runtime: python@3.11
    command: uvicorn worker.main:app --reload
    env:
      - REDIS_URL=${secrets:redis_url}
  db:
    image: postgres:15-alpine
    env:
      POSTGRES_USER: dev
      POSTGRES_PASSWORD: dev
      POSTGRES_DB: app_dev
    ports:
      - 5432:5432
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "dev"]
      interval: 2s
      timeout: 5s
      retries: 5

The runtime field abstracts away the version manager. The CLI automatically installs node@18 and python@3.11 if they aren’t present, using the same mechanism that asdf does under the hood.
Secrets are referenced with the ${secrets:…} syntax. When the CLI starts, it contacts the configured secret store (AWS Secrets Manager, HashiCorp Vault, or a simple .env fallback) and injects the values into the process environment, eliminating the need for multiple .env files.
The healthcheck block ensures the db container is ready before the API attempts to connect, removing the “connection refused” race condition that plagued earlier setups.

$ continue dev up
⏳ Resolving runtimes...
✔️ Node 18.17.0 installed
✔️ Python 3.11.5 installed
🔐 Fetching secrets from vault...
✔️ Secrets injected
🚀 Starting containers...
[db]   ✔️ Ready (port 5432)
[api]  ✔️ Listening on http://localhost:3000
[worker] ✔️ Running on http://localhost:8000
🟢 All services are up and healthy

What changed?

No manual version installs. The CLI automatically aligns your development machine with the exact versions defined in the manifest. If a teammate updates the manifest to node@20, the next continue dev up will download and switch to that version without extra steps.
Zero secret‑management friction. You never have to copy a .env.example again. The CLI pulls live values (or a local fallback) the moment it launches the process.
Deterministic startup order. The dependency graph guarantees that the db container passes its healthcheck before the API starts, eliminating random failures that used to appear only in CI.
One‑command reproducibility. The entire stack can be brought up on a fresh VM with a single line, making pair‑programming sessions, hackathons, and CI runners much more reliable.

Beyond onboarding, the CLI also helps catch configuration drift early. Because the manifest is version‑controlled, any change to a runtime or secret reference appears as a git diff, prompting a review just like code changes.

Clone the repo.