Dev Command Center — general guide

Use DCC as your local command center for agents and terminals

The main flow is simple: pick a project, create a workspace for the task, open terminals and agents side by side, review the changes and decide what ships. The AI suggests; you approve.

Get started Workbench Provider handoff Delegate Skills Credentials Mobile Tailscale References

Project

Pick a local Git repository for DCC to track.

~/projects/my-api

Workspace

Create a workspace for a specific task, branch or review.

feat/checkout-stripe

Panes

Open terminal, Claude, Gemini, Codex or Cursor side by side in the workspace.

Terminal + Claude + Gemini

Attention

Track when an agent finished, needs you or produced changes to review.

toast + sidebar + local history

First use

How to get started without getting lost

Think of DCC as a workbench: every task should live inside an explicit workspace. That avoids pointless branch swaps, cuts context switching and keeps each agent working in the right place.

Download the desktop app from GitHub Releases.

Open the app and register a local Git repository.

Create a new workspace for the current task.

Open terminal and agent Panes as you need them.

Review diffs, run tests and commit at your own pace.

Mental model of the flow

1. Open the project
2. Create a workspace for the task
3. Open a terminal to run the app
4. Open an agent to implement
5. Open another agent to review/test
6. Review, test and commit

Workbench

The surfaces you use during a task

DCC brings review, code, terminal, planning and agents into the same flow. The idea is simple: find the right context, pick what matters and send it to the agent when you need help.

Inspector

Use it to review the tree of changed files, open diffs and decide what deserves attention before applying or committing.

1Open Inspector → Changes in the workspace.
2Click a file to see the diff.
3Select a snippet, file or relevant finding.
4Send it to Composer or to an agent with the selection as context.

Code dock

Use it as a mini editor inside DCC to read, tweak and isolate snippets without leaving the workbench.

1Open the file in the code dock.
2Select a function, snippet or problematic block.
3Send the selection to the agent to explain, refactor or write tests.
4Go back to Inspector to check the diff after the change.

Terminals

Use terminals for commands you want to drive yourself: dev server, tests, lint, migrations, Git and diagnostics.

1Open a terminal Pane in the workspace.
2Run commands in the same context as the task.
3Keep logs visible while agents are working.
4Use the terminal output as context for Composer when needed.

Composer and Plan

Use Composer to talk to the agent and Plan mode when you want to align on strategy before touching code.

1Describe the goal in Composer.
2Ask for a plan before implementation.
3Review steps, risks and likely files.
4Approve the path and only then move to implementation.

Spec

Use specs to turn an ambiguous task into a clear definition of goal, scope, criteria and verification.

1Create or open a spec in the workspace.
2Capture the goal, out-of-scope items and acceptance criteria.
3Use the spec as context for agents.
4Update the spec whenever the product or engineering decision changes.

Open in your favorite IDE

Use this when you need heavier editing in the editor you already use, while keeping DCC as your coordination hub.

1Pick your preferred IDE in settings when applicable.
2Open the workspace in Cursor, Zed or VS Code.
3Edit in the editor and track changes in Inspector.
4Come back to DCC to review, delegate, test and commit.

Provider handoff

Continue the same task with another provider

There is no separate transfer command. In a session that already has history, select another provider in Composer and send the next message normally. DCC detects the switch and attaches one bounded re-anchor.

Direct flow

1Work normally in an existing task.
2Select another provider; DCC tells you that limited context will follow on the next turn.
3Write and send the next message as usual.
4The new runtime receives the re-anchor; later turns with it return to the normal flow.

What follows the switch

Current workspace, path and branch.

A bounded Git state summary.

Mission spec and active plan, when available.

Recent completed user and agent messages.

This is a deterministic, bounded re-anchor, not native 1:1 memory between providers. The full transcript, hidden reasoning, tool noise and raw Git patches are not sent. A new task or thread starts fresh.

Continuing the same task?

Use provider handoff: same session, same timeline and same worktree. Just select the new provider and send.

Separating, comparing or reviewing before apply?

Use delegation: a child session receives its own objective and, for implementation, works in an isolated worktree you can apply or discard.

Delegation

What to delegate and how to run it

Terminal

Deterministic commands, logs, tests, build and Git.

yarn testnpm run lintgit diff --statgit status --short

CLI agent

Natural-language code tasks, always inside the open workspace.

claudegeminicodex

Provider in DCC

The runtime/provider you chose in the workbench for compatible sessions, Panes and delegations.

ClaudeGeminiCodexCursor

Hotfix without losing context

1Create a temporary workspace from the production branch.
2Open a terminal Pane to reproduce the bug.
3Delegate an agent to investigate the root cause and propose a small patch.
4Run tests in the terminal, review the diff and commit only when you're happy.

Example prompt

Investigate the login failure in this workspace. Propose the smallest possible patch, explain the risk and wait for my review before widening the scope.

Refactor with parallel tests

1Open a workspace for the refactor.
2Use a Pane with Claude/Codex to change the architecture.
3Use another Pane with Gemini to create tests and edge cases.
4Use the terminal to run the test suite, lint and inspect the final diff.

Example prompt

Refactor this module while keeping the public contract. List changed files, risks and verification commands. Don't change behavior outside the scope.

Local PR review

1Create a workspace from the PR branch.
2Open a terminal to install/run the project without touching your main setup.
3Delegate an agent to review regressions, missing tests and readability.
4Validate manually and close the workspace when done.

Example prompt

Review this branch as a code review. Prioritize bugs, regressions, operational risk and missing tests. Reply with findings grouped by severity.

Delegate a plan for another model to execute

The safest flow for bigger changes is to split planning from execution. Use one model in the main session to plan in Plan mode, approve the path, then delegate implementation to another model in an isolated worktree.

The main session stays the place where decisions happen.

The executor model receives the full plan and required context.

The implementation shows up as a reviewable diff in Inspector.

You apply, ask for a tweak or discard — without mixing in half-done work.

Payload sent to the executor

Implement the plan below using the current workspace.

<full plan captured by Plan mode>

Execution criteria:
- Keep the implementation scoped to this plan.
- Preserve the planner's frontend/design decisions.
- Use the repository's existing patterns and available project skills/instructions.
- Run focused validation where practical and report the exact commands/results.
- End with a concise summary of changed files, decisions, and validation.

Plan with one model, implement with another

Use this when you want one model to think through strategy, UX or architecture before another model touches the code.

Prompt for the planner

Plan a compact improvement to the documentation page. Focus on end-user clarity, section order and practical examples. Don't implement yet.

1Open the conversation with the planner model.
2Turn on Plan mode before sending the request.
3Review the returned plan and adjust the scope if needed.
4Click Delegate plan.
5Keep Implement and Full reanchor so the executor gets plan, context and diff.
6Send it to the implementation provider — Codex, for example.
7Review the diff in Inspector before applying.

Optional line for the executor

Preserve the plan's decisions. Run the most focused validation possible and end with changed files, decisions and command results.

Turn an investigation into an isolated fix

Use this when the planner already found the likely cause of a bug and you want to test the fix without polluting your main workspace.

Prompt for the planner

Investigate why the plan banner keeps appearing after the task was already delegated. Return a short plan with likely files, risk and validation. Don't edit files.

1Read the plan and confirm the root cause makes sense.
2Click Delegate plan to open the pre-filled delegation.
3Add a test constraint if it isn't already in the plan.
4Run the delegation in Implement.
5Use Inspector to review changed files and the diff.
6If it's almost right, send feedback for the child session to correct it.
7Apply only when the result is ready.

Optional line for the executor

Include or update focused tests for the state that hides the banner after delegation.

Spec becomes a plan, plan becomes implementation

Use this when the task has acceptance criteria and you want to keep a reviewable Spec → Plan → Implementation trail.

Prompt for the planner

Generate a plan from this spec. Cover criteria AC-1, AC-2 and AC-3 explicitly. Don't implement yet.

1Create or open the task spec.
2Use Generate plan to request the plan in Plan mode.
3Check that the steps cite the acceptance criteria.
4Click Delegate plan.
5Keep Full reanchor so it carries spec, plan and session summary.
6Review the implementation against the criteria in Inspector.
7Apply or discard the isolated worktree.

Optional line for the executor

In the final summary, state which criteria were covered and which commands validated the delivery.

Full reanchor

Best for Delegate plan. Sends the session summary, spec, plan and diff so the executor continues from the approved intent.

Review current diff

Best for a second opinion on the current changes, without asking for a new implementation.

Minimal

Best for small questions where too much context would only get in the way of the answer.

What you control in a delegation

You pick the provider and the task type: Review, Explain or Implement.

Review produces a second opinion on the work.

Explain investigates and explains an area of the code.

Implement creates a change proposal for you to review.

Inspector shows changed files and diffs before you apply.

You can send feedback so the agent improves the proposal.

You apply the result when you're satisfied.

You discard the delegation when you don't want to use the result.

DCC Skills

Reuse instructions across multiple agents

Skills are reusable instructions DCC uses to guide agents on common project tasks. Instead of repeating the same prompt every time, you create a skill, pick the agents that should use it and keep working.

One home for team patterns

Create skills for recurring tasks like reviewing PRs, writing tests, investigating bugs, prepping a release or documenting a change.

Available across agents

Once saved, DCC makes the skill available to the agents you chose. No need to rewrite the same prompt in each tool.

Usage control

Pick which agents get the skill and turn off automatic invocation when you'd rather use the instruction as manual reference only.

Useful skill examples

review-pr

Review changes for risk, regressions and missing tests.

write-tests

Generate tests for the current feature following the repo's patterns.

investigate-bug

Read logs, map the likely root cause and propose the smallest fix.

document-feature

Update the README, usage docs and examples for the change.

Claude

Good for refactoring, explanation and context-driven implementation.

Pick Claude when the skill should steer Claude sessions inside DCC.

Codex

Good for code engineering, review, tests and repo maintenance.

Pick Codex when the skill should steer Codex sessions opened by DCC.

Gemini

Good for wide analysis, test generation and long-context reading.

Pick Gemini when the skill should steer Gemini sessions in the workspace.

Cursor

Good for keeping project rules aligned with the editor.

Pick Cursor when the skill should follow the editing flow in Cursor.

Flow inside the app

1Open a project/workspace in DCC.
2Open Skills from the workbench.
3Create a skill with name, description and instructions.
4Pick the agents that should receive that skill.
5Save the skill.
6Open a Pane for the chosen agent and use the skill in your workflow.

Instruction example

Name: review-pr
Description: review a branch before opening or updating a PR

Instruction:
- Prioritize bugs, regressions and missing tests.
- Cite file and line whenever possible.
- Suggest fixes, but wait for my approval.
- End with the verification commands.

Credentials

Set up GitHub, GitLab and providers for DCC

For DCC to use GitHub, GitLab, CodeRabbit, Codex, Claude, Gemini or Cursor, log into the matching tools on the machine where the app is installed. Then open DCC and pick the project as usual.

GitHub

Log into the GitHub CLI so DCC can open, query and prepare PRs for GitHub repositories.

GitHub setup

brew install gh
gh auth login
gh auth status
gh auth setup-git
gh repo clone owner/repo

Official docs

GitLab

Log into the GitLab CLI so DCC can work with GitLab projects, including self-managed instances.

GitLab setup

brew install glab
glab auth login
glab auth status
glab auth login --hostname gitlab.example.com
glab repo clone group/project

Official docs

Codex / OpenAI

Log into Codex before opening a Codex Pane in DCC. Use device auth when you're in an environment without a browser.

Codex / OpenAI setup

codex login
codex login --device-auth
codex
codex --help
ls ~/.codex

Official docs

CodeRabbit

In Settings > Account, connect the CodeRabbit CLI. Then run reviews in Inspector > Changes and choose which findings to send to Composer.

GitHub or GitLab

When the project has a GitHub or GitLab remote, DCC shows PR/MR context and uses the account authenticated in the matching CLI.

Providers

Claude, Gemini, Codex and Cursor need to be installed and authenticated on the machine. DCC opens those agents in the selected workspace.

Useful checks

export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."
export GEMINI_API_KEY="..."
claude doctor
gemini --version
codex --version

Mobile access

Pair your phone with the Desktop

Mobile access lets you follow the workbench when you're away from the main screen. Pair your phone with the QR and use the mobile panel to see running agents and items that need your attention.

1On the Desktop, open Settings → Connections → Pair new device.
2Pick LAN if your phone is on the same network, or Tailscale if you're using a private network.
3Scan the QR with your phone.
4Type the 6-digit PIN shown on the Desktop before it expires.
5Once paired, follow panes, running agents and items that need your attention.

Best practices

Use a trusted network

Prefer your home network, office or Tailscale. Avoid public Wi-Fi for pairing.

Enable notifications

Use mobile to notice when an agent finished or is waiting for a reply.

Revoke when needed

If you switch devices or lose your phone, remove the paired device in Settings.

Network

Options for connecting mobile

Same Wi-Fi network

Use this when desktop and phone are on the same Wi-Fi. It's the simplest option for home or a trusted office.

Tailscale

Use this when you want to connect phone and desktop even off the same network, with both on your tailnet.

Secure link

If the browser blocks pairing for security reasons, use the link DCC recommends or connect via Tailscale.

Linux

curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up
tailscale status
tailscale ip -4

macOS with Homebrew

brew install --cask tailscale
open -a Tailscale
tailscale status
tailscale ip -4

iPhone or Android

Install Tailscale from the App Store or Google Play, sign in with the same account/tailnet as the Desktop and confirm the device shows up in `tailscale status` on the computer.

DCC flow

With Tailscale running on desktop and phone, open Settings → Connections → Pair new device, choose the Tailscale endpoint and scan the QR with your phone.

Useful links: Tailscale downloads, Linux install.

Product documents

Codex orchestration

Configure Sol, Terra subagents, the orchestration preset, concurrency and end-to-end testing.

Read document

What the product is

Definition, audience, problems it solves and DCC's limits.

Read document

Positioning

Public language and narrative for the product.

Read document

Product status

Current phase, public distribution and supported scope.

Read document