# Droid CLI Quickstart

Install the Droid CLI, start an interactive terminal session, and delegate your first reviewable coding task.

Use this quickstart to install the Droid CLI, start an interactive terminal session, and delegate a first scoped task. You will see how Droid reads your codebase, proposes changes, and waits for review before editing.

## Before you begin

Make sure you have:

<Checklist>
  <ChecklistItem status="pass">A terminal open in a code project</ChecklistItem>
  <ChecklistItem status="neutral">
    A Git repository (recommended for the full workflow demonstration)
  </ChecklistItem>
</Checklist>

## Step 1: Install and start Droid

**macOS/Linux:** `curl -fsSL https://app.factory.ai/cli | sh`

**Homebrew:** `brew install --cask droid`

**Windows:** `irm https://app.factory.ai/cli/windows | iex`

**npm:** `npm install -g droid`

<Note>
  **Linux users:** Ensure `xdg-utils` is installed for proper functionality. Install with: `sudo apt-get install xdg-utils`
</Note>

Then navigate to your project and start the Droid CLI.

<Terminal title="bash" command={`cd /path/to/your/project
droid`} />

<DocsSurfacePreview surface="cli" caption="Droid CLI starts in your terminal with modes, autonomy, MCP status, and prompt composer visible." />

You'll see Droid's welcome screen in a full-screen terminal interface. If prompted, sign in via your browser to connect to Factory's development agent.

## Step 2: understand your codebase

Start by asking Droid to map the project before it edits anything:

```text
> analyze this codebase and explain the overall architecture
```

```text
> where are the main entry points, test commands, and code conventions?
```

Droid reads the files it needs, summarizes the architecture, and identifies the checks it should run before making changes.

## Step 3: run your first reviewable change

Ask for one small, verifiable change:

```text
> add structured logging to the app entry point and replace the existing console calls
```

Droid will:

1. Inspect the current implementation.
2. Propose a plan when the task needs one.
3. Show the exact diff.
4. Wait for approval before editing.
5. Run the relevant validators when you ask it to finish the task.

Review the diff and run the relevant tests before accepting the change. This propose-and-approve loop is how you keep control as you delegate more work.

## Step 4: pick a goal to go deeper

<CardGroup cols={2}>
  <Card title="Implement larger features" icon="diagram-project" href="/autonomy-and-safety/specification-mode">
    Use Specification Mode so Droid writes a plan before it starts a multi-step implementation.
  </Card>
  <Card title="Review and harden changes" icon="shield-check" href="/software-factory/code-review">
    Review pull requests and local diffs for correctness, security, and edge cases.
  </Card>
  <Card title="Automate headless work" icon="terminal" href="/droid-exec/overview">
    Move repeatable workflows into Droid Exec for scripts, CI, scheduled jobs, and pull request checks.
  </Card>
  <Card title="Coordinate multi-step work" icon="sitemap" href="/missions/overview">
    Use Factory Missions when a task needs planning, delegation, validation, and checkpoints.
  </Card>
</CardGroup>

## Step 5: handle version control

Droid makes Git operations conversational and intelligent:

```text
> review my uncommitted changes and suggest improvements before I commit
```

```text
> create a well-structured commit with a descriptive message following our team conventions
```

## Essential controls

Here are the key interactions you'll use daily:

| Action            | What it does                                          | How to use                                   |
| ----------------- | ----------------------------------------------------- | -------------------------------------------- |
| Send message      | Submit a task or question                             | Type and press <Kbd>Enter</Kbd>                     |
| Multi-line input  | Write longer prompts                                  | <Kbd keys='Shift+Enter' /> for new lines               |
| Approve changes   | Accept proposed modifications                         | Accept change in the TUI                     |
| Reject changes    | Decline proposed modifications                        | Reject change in the TUI                     |
| Switch modes      | Toggle between modes                                  | <Kbd keys='Shift+Tab' />                               |
| Bash mode         | Run shell commands directly without AI interpretation | Press <Kbd>!</Kbd> on an empty input; <Kbd>Esc</Kbd> to return |
| Transcript view   | Toggle detailed transcript with full message details  | <Kbd keys='Ctrl+O' />                                   |
| Mission Control   | Toggle Mission Control overlay (orchestrator sessions)| <Kbd keys='Ctrl+T' />                                   |
| Close overlay     | Dismiss the active overlay or menu                    | <Kbd>Escape</Kbd>                                   |
| Scroll transcript | Navigate through previous turns                       | <Kbd keys='Alt+Up' /> / <Kbd keys='Alt+Down' />                    |
| View shortcuts    | See all available commands                            | Press <Kbd>?</Kbd>                                  |
| Exit session      | Leave droid                                           | <Kbd keys='Ctrl+C' /> or type `exit`                   |

### Useful slash commands

Quick shortcuts to common actions:

| Command | What it does |
| :------ | :----------- |
| `/review` | Start the code review workflow ([learn more](/software-factory/code-review)). |
| `/settings` | Configure droid behavior, models, and preferences. |
| `/model` | Switch between AI models mid-session. |
| `/sessions` | List and resume previous sessions. |
| `/fork` | Fork the current session into a new branch. |
| `/compress` | Compress the current session to free up context. |
| `/missions` | Open the Missions menu to launch multi-agent projects. |
| `/droids` | Manage custom Droids (specialized subagents). |
| `/skills` | Manage prompt-based skills (reusable procedures). |
| `/hooks` | Manage tool execution hooks for lifecycle automation. |
| `/plugins` | Manage plugins and marketplaces. |
| `/mcp` | Manage Model Context Protocol servers. |
| `/account` | Open your Factory account settings in the browser. |
| `/billing` | View and manage your billing settings. |
| `/help` | See all available commands. |

[Learn how to create custom slash commands →](/harness/custom-slash-commands)

<RelatedLinks>
  <RelatedLink href='/software-factory/wiki/overview' title='AutoWiki'>
    Turns a repository into browsable architecture and setup documentation.
  </RelatedLink>
  <RelatedLink href='/software-factory/code-review' title='Local Code Review'>
    Starts `/review` for uncommitted changes, commits, and branch diffs.
  </RelatedLink>
  <RelatedLink href='/agent-readiness/overview' title='Agent Readiness'>
    Scores whether a repository is ready for larger autonomous work.
  </RelatedLink>
  <RelatedLink href='/harness/agents-md' title='AGENTS.md'>
    Teaches Droid repository-specific conventions before it edits code.
  </RelatedLink>
</RelatedLinks>