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

# Using commands

> Slash commands to manage context, plan complex tasks, create reusable rules, and generate git commit messages.

Cline provides slash commands in the chat input that help you manage your conversation, control context, and plan complex implementations. Type `/` to see the full list.

<Tip>
  Watch the [slash commands walkthrough](https://youtu.be/MxS5Jerpf-o) for a quick overview.
</Tip>

## Slash commands

| Command            | What it does                                                                   |
| ------------------ | ------------------------------------------------------------------------------ |
| `/newtask`         | Start a fresh task with distilled context from the current conversation        |
| `/smol`            | Compress conversation history while preserving essential context               |
| `/newrule`         | Create a rule file to teach Cline your preferences                             |
| `/deep-planning`   | Investigate your codebase, plan thoroughly, then create an implementation task |
| `/explain-changes` | Generate AI-powered explanations for any git diff (VS Code only)               |
| `/reportbug`       | Report a bug with diagnostic information                                       |

### /newtask

`/newtask` works like a developer handoff. It packages what matters — the overall plan, work accomplished, relevant files, next steps — into a fresh task with a clean context window, leaving behind the noise of tool calls and implementation details.

Use `/newtask` when you've completed several steps of a longer process and your context window is getting full. Cline extracts the key decisions and progress into the new task without carrying over unnecessary noise.

### /smol

`/smol` (or its alias `/compact`) compresses your conversation history while preserving essential context. Unlike `/newtask`, which creates a new task, `/smol` condenses your current conversation into a comprehensive summary and keeps you in the same task thread.

Use `/smol` when you're deep into a debugging session or brainstorming and need to continue in the same task without losing the insights you've built up.

### /newrule

`/newrule` creates a rule file that teaches Cline your preferences. Cline walks you through setting up guidelines for communication style, coding standards, project context, and workflows. The rule is saved to your `.clinerules` directory and loaded automatically for future conversations.

Use `/newrule` when you find yourself repeating the same instructions across tasks. For more about rules, see [Cline Rules](/customization/cline-rules).

### /deep-planning

`/deep-planning` transforms Cline into a meticulous architect: it investigates your codebase, asks clarifying questions, and creates a comprehensive implementation plan before writing any code.

Deep planning follows a four-step process:

<Steps>
  <Step title="Silent investigation">
    Cline explores your codebase structure and patterns without asking questions yet.
  </Step>

  <Step title="Discussion">
    Cline asks targeted questions about requirements, constraints, and preferred approach.
  </Step>

  <Step title="Plan creation">
    Cline generates an `implementation_plan.md` file with detailed specifications, file paths, and step-by-step instructions.
  </Step>

  <Step title="Task creation">
    Cline creates a new task with trackable implementation steps based on the plan.
  </Step>
</Steps>

Use `/deep-planning` for features that touch multiple parts of your codebase, architectural changes, or complex integrations. For full details, see [Deep Planning](/features/deep-planning).

### /explain-changes

<Note>
  This command is only available in VS Code.
</Note>

`/explain-changes` generates AI-powered explanations for any git diff. You can explain:

* The last commit
* Uncommitted or staged changes
* Specific commits or commit ranges
* Branches and pull requests

Use `/explain-changes` when reviewing code, onboarding to a new codebase, or understanding the impact of a set of changes.

### /reportbug

`/reportbug` collects diagnostic information — your configuration, recent errors, system details — and helps you file a useful bug report with the Cline development team.

Use `/reportbug` when you encounter unexpected behavior, crashes, or anything you want to report.

## Terminal integration

Cline integrates directly with your editor's terminal using the [shell integration API introduced in VS Code v1.93](https://code.visualstudio.com/updates/v1_93#_terminal-shell-integration-api).

Cline can:

* Execute commands in your terminal and read their output
* Install packages, run build scripts, and execute tests
* Monitor a running dev server and react to new output (such as compile errors)
* Continue working while a long-running process runs in the background

For processes that don't exit on their own — like a dev server — click **Proceed While Running** to let Cline continue with the task while the command runs in the background. Cline is notified of new terminal output as it appears.

## Git commit message generation

In the Source Control panel, right-click on your staged changes and select **Generate Commit Message**. Cline analyzes the diff and writes a descriptive commit message following conventional commit patterns.

This is a quick way to produce consistent, meaningful commit messages without context-switching to write them manually.

## Custom workflows

Beyond the built-in slash commands, you can create your own workflow files that work exactly the same way. Store Markdown files in `.clinerules/workflows/` and invoke them with `/your-workflow-name`.

For a complete guide on creating and managing custom workflows, see [Workflows](/customization/workflows).