> ## Documentation Index
> Fetch the complete documentation index at: https://docs.factory.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Quickstart
> Get productive with droid in 5 minutes using the interactive terminal UI.
This quickstart guide will have you collaborating with Factory's development agent in just a few minutes. You'll experience how droid understands your codebase, makes thoughtful changes, and integrates with your existing workflow.
## Before you begin
Make sure you have:
* A terminal open in a code project
* Git repository (recommended for full workflow demonstration)
## Step 1: Install and start droid
```bash macOS/Linux theme={null}
curl -fsSL https://app.factory.ai/cli | sh
```
```bash Homebrew theme={null}
brew install --cask droid
```
```powershell Windows theme={null}
irm https://app.factory.ai/cli/windows | iex
```
```bash npm theme={null}
npm install -g droid
```
**Linux users:** Ensure `xdg-utils` is installed for proper functionality. Install with: `sudo apt-get install xdg-utils`
Then navigate to your project and start the droid CLI.
```bash theme={null}
# Navigate to your project
cd /path/to/your/project
# Start interactive session
droid
```
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: Explore your codebase
Let's start by having droid understand your project. Try one of these questions:
```
> analyze this codebase and explain the overall architecture
```
```
> what technologies and frameworks does this project use?
```
```
> where are the main entry points and how is testing set up?
```
Droid reads your files contextually and leverages organizational knowledge to provide comprehensive insights about your project structure and conventions.
## Step 3: Make your first code change
Now let's see droid in action with a simple modification:
```
> add comprehensive logging to the main application startup
```
Droid will:
1. Analyze your current logging setup
2. Propose specific changes with a clear plan
3. Show you exactly what will be modified
4. Wait for your approval before making changes
This transparent review process ensures you maintain full control over all code modifications.
## Step 4: Experience enterprise workflows
Try a more complex task that showcases droid's enterprise capabilities:
```
> audit this codebase for security vulnerabilities and create a remediation plan
```
Or provide context from your team's tools by pasting a link:
```
> implement the feature described in this Jira ticket: https://company.atlassian.net/browse/PROJ-123
```
If you've integrated these platforms through Factory's dashboard, droid can automatically read context from Jira, Notion, Slack, and other sources. Droid can also connect to additional tools via MCP integrations for even more capabilities.
## Step 5: Handle version control
Droid makes Git operations conversational and intelligent:
```
> review my uncommitted changes and suggest improvements before I commit
```
```
> create a well-structured commit with a descriptive message following our team conventions
```
```
> analyze the last few commits and identify any potential issues or patterns
```
## 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 **Enter** |
| Multi-line input | Write longer prompts | **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 | **Shift+Tab** |
| Bash mode | Run shell commands directly without AI interpretation | Press `!` on an empty input; `Esc` to return |
| View shortcuts | See all available commands | Press **?** |
| Exit session | Leave droid | **Ctrl+C** or type `exit` |
### Useful slash commands
Quick shortcuts to common actions:
* `/review` - Start AI-powered code review workflow ([learn more](/cli/features/code-review))
* `/settings` - Configure droid behavior, models, and preferences
* `/model` - Switch between AI models mid-session
* `/mcp` - Manage Model Context Protocol servers
* `/account` - Open your Factory account settings in browser
* `/billing` - View and manage your billing settings
* `/help` - See all available commands
[Learn how to create custom slash commands →](/cli/configuration/custom-slash-commands)
## Collaboration best practices
**Be specific with context:**
Instead of: "fix the bug"
Try: "fix the authentication timeout issue where users get logged out after 5 minutes instead of the configured 30 minutes"
**Use spec mode for complex features:**
For larger features, use [Specification Mode](/cli/user-guides/specification-mode) which automatically provides planning before implementation without needing to explicitly request it.
**Leverage organizational knowledge:**
```
> following our team's coding standards, implement the user preferences feature described in ticket PROJ-123
```
**Use the review workflow:**
Always review droid's proposed changes before approval. The transparent diff view helps you understand exactly what will be modified.
## Pro tips for enterprise teams
**Security-first approach:**
Droid automatically considers security implications and will flag potential vulnerabilities during code generation.
**Compliance integration:**
Connect your compliance tools through MCP to ensure all changes meet your organization's standards.
**Team knowledge sharing:**
Droid learns from your organization's patterns and can help maintain consistency across team members and projects.
## What's next?
Explore real-world scenarios and workflows
Customize droid for your team's workflow
Document your project conventions and commands
Use droid within your favorite editor
```
```