# Verbose Mode

This guide explains how to use DeepLint's verbose mode to get more detailed information about command execution.

## Overview

DeepLint provides a verbose mode that outputs additional information during command execution. This can be helpful for:

* Debugging issues with DeepLint
* Understanding what DeepLint is doing behind the scenes
* Getting more context about the analysis process
* Troubleshooting configuration problems

## Basic Usage

To enable verbose mode, use the `--verbose` flag or its shorthand `-v`:

```bash
deeplint --verbose
```

This will run the default command with verbose output enabled.

You can also use verbose mode with specific commands:

```bash
deeplint init --verbose
deeplint help --verbose
```

{% hint style="info" %}
Verbose mode is different from debug mode (`--debug`). Verbose mode provides additional information about what DeepLint is doing, while debug mode provides detailed technical information for debugging purposes.
{% endhint %}

## What Verbose Mode Shows

When verbose mode is enabled, DeepLint will output additional information about:

* Configuration loading and validation
* Command execution steps
* Context building process
* File scanning and analysis
* Git operations
* Command-specific operations

For example, when running the default command with verbose mode:

```bash
deeplint --verbose
```

You'll see additional output like:

```
🔊 Context building configuration:
🔊 - Repository root: /path/to/your/project
🔊 - Context type: light
🔊 - Include unstaged changes: false
🔊 - Max tokens: 8000
🔊 - Include dependencies: false
🔊 - Include structure: true
🔊 Starting context building process...
🔊 Context building process completed.
🔊 Context building statistics:
🔊 - Total files: 42
🔊 - Changed files: 3
🔊 - Related files: 5
🔊 - Total tokens: 2500
🔊 - Build time: 120ms
```

## Combining with Other Flags

Verbose mode can be combined with other flags:

```bash
deeplint --verbose --unstaged
```

This will run the default command with verbose output and include unstaged changes in the analysis.

## Examples

Here are some examples of using verbose mode with different commands:

{% tabs %}
{% tab title="Default Command" %}

```bash
deeplint --verbose
```

Runs the default command with verbose output, showing detailed information about the context building process.
{% endtab %}

{% tab title="Init Command" %}

```bash
deeplint init --verbose
```

Initializes DeepLint with verbose output, showing detailed information about the configuration file creation process.
{% endtab %}

{% tab title="Help Command" %}

```bash
deeplint help --verbose
```

Displays help information with verbose output, showing detailed information about the help command execution.
{% endtab %}
{% endtabs %}

## When to Use Verbose Mode

Verbose mode is particularly useful in the following scenarios:

1. **Troubleshooting**: When DeepLint isn't behaving as expected, verbose mode can help identify where the issue is occurring.
2. **Learning**: If you're new to DeepLint, verbose mode can help you understand what's happening behind the scenes.
3. **Complex Projects**: In large projects with many files, verbose mode can provide insights into how DeepLint is analyzing your code.
4. **Custom Configurations**: If you've customized your DeepLint configuration, verbose mode can help verify that your settings are being applied correctly.

## Next Steps

Now that you understand how to use verbose mode, you can:

1. Try running DeepLint with verbose mode to see the additional information it provides
2. Use verbose mode to troubleshoot any issues you encounter
3. Learn more about [DeepLint's configuration options](https://docs.deeplint.com/getting-started/configuration)

For more information about DeepLint's commands, see the [Help Command](https://docs.deeplint.com/user-guide/default-command/help) guide.