> ## Documentation Index
> Fetch the complete documentation index at: https://cli.fuxicode.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart

> Welcome to Fuxi Code!

This quickstart guide will have you using AI-powered coding assistance in a few minutes. By the end, you'll understand how to use Fuxi Code for common development tasks.

## Before you begin

Make sure you have:

* A terminal or command prompt open
  * If you've never used the terminal before, check out the [terminal guide](/en/terminal-guide)
* A code project to work with
* A [Fuxi subscription](https://fuxi.com/pricing?utm_source=fuxi_code\&utm_medium=docs\&utm_content=quickstart_prereq) (Pro, Max, Team, or Enterprise), [Fuxi Console](https://console.anthropic.com/) account, or access through a [supported cloud provider](/en/third-party-integrations)

<Note>
  This guide covers the terminal CLI. Fuxi Code is also available on the [web](https://fuxi.ai/code), as a [desktop app](/en/desktop), in [VS Code](/en/vs-code) and [JetBrains IDEs](/en/jetbrains), in [Slack](/en/slack), and in CI/CD with [GitHub Actions](/en/github-actions) and [GitLab](/en/gitlab-ci-cd). See [all interfaces](/en/overview#use-fuxi-code-everywhere).
</Note>

## Step 1: Install Fuxi Code

To install Fuxi Code, use one of the following methods:

<Tabs>
  <Tab title="Native Install (Recommended)">
    **macOS, Linux, WSL:**

    ```bash theme={null}
    curl -fsSL https://fuxi.ai/install.sh | bash
    ```

    **Windows PowerShell:**

    ```powershell theme={null}
    irm https://fuxi.ai/install.ps1 | iex
    ```

    **Windows CMD:**

    ```batch theme={null}
    curl -fsSL https://fuxi.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
    ```

    If you see `The token '&&' is not a valid statement separator`, you're in PowerShell, not CMD. If you see `'irm' is not recognized as an internal or external command`, you're in CMD, not PowerShell. Your prompt shows `PS C:\` when you're in PowerShell and `C:\` without the `PS` when you're in CMD.

    If the install command fails with `syntax error near unexpected token '<'`, a `403`, or another curl error, see [Troubleshoot installation](/en/troubleshoot-install#find-your-error) to match the error to a fix and for alternative install methods.

    [Git for Windows](https://git-scm.com/downloads/win) is recommended on native Windows so Fuxi Code can use the Bash tool. If Git for Windows is not installed, Fuxi Code uses PowerShell as the shell tool instead. WSL setups do not need Git for Windows.

    <Info>
      Native installations automatically update in the background to keep you on the latest version.
    </Info>
  </Tab>

  <Tab title="Homebrew">
    ```bash theme={null}
    brew install --cask fuxi-code
    ```

    Homebrew offers two casks. `fuxi-code` tracks the stable release channel, which is typically about a week behind and skips releases with major regressions. `fuxi-code@latest` tracks the latest channel and receives new versions as soon as they ship.

    <Info>
      Homebrew installations do not auto-update. Run `brew upgrade fuxi-code` or `brew upgrade fuxi-code@latest`, depending on which cask you installed, to get the latest features and security fixes.
    </Info>
  </Tab>

  <Tab title="WinGet">
    ```powershell theme={null}
    winget install Anthropic.FuxiCode
    ```

    <Info>
      WinGet installations do not auto-update. Run `winget upgrade Anthropic.FuxiCode` periodically to get the latest features and security fixes.
    </Info>
  </Tab>
</Tabs>

You can also install with [apt, dnf, or apk](/en/setup#install-with-linux-package-managers) on Debian, Fedora, RHEL, and Alpine.

## Step 2: Log in to your account

Fuxi Code requires an account to use. Start an interactive session with the `fuxi` command and you'll be prompted to log in on first use:

```bash theme={null}
fuxi
```

For Fuxi subscription or Console accounts, follow the prompts to complete authentication in your browser. To switch accounts later or re-authenticate, type `/login` inside the running session:

```text theme={null}
/login
```

You can log in using any of these account types:

* [Fuxi Pro, Max, Team, or Enterprise](https://fuxi.com/pricing?utm_source=fuxi_code\&utm_medium=docs\&utm_content=quickstart_login) (recommended)
* [Fuxi Console](https://console.anthropic.com/) (API access with pre-paid credits). On first login, a "Fuxi Code" workspace is automatically created in the Console for centralized cost tracking.
* [Amazon Bedrock, Google Cloud's Agent Platform, or Microsoft Foundry](/en/third-party-integrations) (enterprise cloud providers)
* A self-hosted [Fuxi apps gateway](/en/fuxi-apps-gateway), if your organization runs one: your admin pre-configures the gateway URL, and `/login` opens directly on the **Cloud gateway** screen for you to sign in with corporate SSO

Once logged in, your credentials are stored and you won't need to log in again.

## Step 3: Start your first session

Open your terminal in any project directory and start Fuxi Code:

```bash theme={null}
cd /path/to/your/project
fuxi
```

You'll see the Fuxi Code prompt with the version, current model, and working directory shown above it. Type `/help` for available commands or `/resume` to continue a previous conversation.

<Tip>
  After logging in (Step 2), your credentials are stored on your system. Learn more in [Credential Management](/en/authentication#credential-management).
</Tip>

## Step 4: Ask your first question

Let's start with understanding your codebase. Try one of these commands:

```text theme={null}
what does this project do?
```

Fuxi will analyze your files and provide a summary. You can also ask more specific questions:

```text theme={null}
what technologies does this project use?
```

```text theme={null}
where is the main entry point?
```

```text theme={null}
explain the folder structure
```

You can also ask Fuxi about its own capabilities:

```text theme={null}
what can Fuxi Code do?
```

```text theme={null}
how do I create custom skills in Fuxi Code?
```

```text theme={null}
can Fuxi Code work with Docker?
```

<Note>
  Fuxi Code reads your project files as needed. You don't have to manually add context.
</Note>

## Step 5: Make your first code change

Now let's make Fuxi Code do some actual coding. Try a simple task:

```text theme={null}
add a hello world function to the main file
```

Fuxi Code will:

1. Find the appropriate file
2. Show you the proposed changes
3. Ask for your approval
4. Make the edit

<Note>
  Fuxi Code always asks for permission before modifying files. You can approve individual changes or enable "Accept all" mode for a session.
</Note>

## Step 6: Use Git with Fuxi Code

Fuxi Code makes Git operations conversational:

```text theme={null}
what files have I changed?
```

```text theme={null}
commit my changes with a descriptive message
```

You can also prompt for more complex Git operations:

```text theme={null}
create a new branch called feature/quickstart
```

```text theme={null}
show me the last 5 commits
```

```text theme={null}
help me resolve merge conflicts
```

## Step 7: Fix a bug or add a feature

Fuxi is proficient at debugging and feature implementation.

Describe what you want in natural language:

```text theme={null}
add input validation to the user registration form
```

Or fix existing issues:

```text theme={null}
there's a bug where users can submit empty forms - fix it
```

Fuxi Code will:

* Locate the relevant code
* Understand the context
* Implement a solution
* Run tests if available

## Step 8: Test out other common workflows

There are a number of ways to work with Fuxi:

**Refactor code**

```text theme={null}
refactor the authentication module to use async/await instead of callbacks
```

**Write tests**

```text theme={null}
write unit tests for the calculator functions
```

**Update documentation**

```text theme={null}
update the README with installation instructions
```

**Code review**

```text theme={null}
review my changes and suggest improvements
```

<Tip>
  Talk to Fuxi like you would a helpful colleague. Describe what you want to achieve, and it will help you get there.
</Tip>

## Essential commands

Here are the most important commands for daily use. Shell commands run from your terminal to start or resume Fuxi Code. Session commands run inside Fuxi Code after it starts.

**Shell commands**

| Command             | What it does                                           | Example                             |
| ------------------- | ------------------------------------------------------ | ----------------------------------- |
| `fuxi`            | Start interactive mode                                 | `fuxi`                            |
| `fuxi "task"`     | Run a one-time task                                    | `fuxi "fix the build error"`      |
| `fuxi -p "query"` | Run one-off query, then exit                           | `fuxi -p "explain this function"` |
| `fuxi -c`         | Continue most recent conversation in current directory | `fuxi -c`                         |
| `fuxi -r`         | Resume a previous conversation                         | `fuxi -r`                         |

**Session commands**

| Command           | What it does               | Example  |
| ----------------- | -------------------------- | -------- |
| `/clear`          | Clear conversation history | `/clear` |
| `/help`           | Show available commands    | `/help`  |
| `/exit` or Ctrl+D | Exit Fuxi Code           | `/exit`  |

See the [CLI reference](/en/cli-reference) for the complete list of shell commands and the [commands reference](/en/commands) for the complete list of session commands.

## Pro tips for beginners

For more, see [best practices](/en/best-practices) and [common workflows](/en/common-workflows).

<AccordionGroup>
  <Accordion title="Be specific with your requests">
    Instead of: "fix the bug"

    Try: "fix the login bug where users see a blank screen after entering wrong credentials"
  </Accordion>

  <Accordion title="Use step-by-step instructions">
    Break complex tasks into steps:

    ```text theme={null}
    1. create a new database table for user profiles
    2. create an API endpoint to get and update user profiles
    3. build a webpage that allows users to see and edit their information
    ```
  </Accordion>

  <Accordion title="Let Fuxi explore first">
    Before making changes, let Fuxi understand your code:

    ```text theme={null}
    analyze the database schema
    ```

    ```text theme={null}
    build a dashboard showing products that are most frequently returned by our UK customers
    ```
  </Accordion>

  <Accordion title="Save time with shortcuts">
    * Type `/` to see all commands and skills
    * Use Tab for command completion
    * Press ↑ for command history
    * Press `Shift+Tab` to cycle permission modes
  </Accordion>
</AccordionGroup>

## What's next?

Now that you've learned the basics, explore more advanced features:

<CardGroup cols={2}>
  <Card title="How Fuxi Code works" icon="microchip" href="/en/how-fuxi-code-works">
    Understand the agentic loop, built-in tools, and how Fuxi Code interacts with your project
  </Card>

  <Card title="Best practices" icon="star" href="/en/best-practices">
    Get better results with effective prompting and project setup
  </Card>

  <Card title="Common workflows" icon="graduation-cap" href="/en/common-workflows">
    Step-by-step guides for common tasks
  </Card>

  <Card title="Extend Fuxi Code" icon="puzzle-piece" href="/en/features-overview">
    Customize with FUXI.md, skills, hooks, MCP, and more
  </Card>
</CardGroup>

## Getting help

* **In Fuxi Code**: Type `/help` or ask "how do I..."
* **Documentation**: You're here! Browse other guides
* **Community**: Join our [Discord](https://www.anthropic.com/discord) for tips and support