# What Is the `enabled_by_default` Property in TheFuck Rules?

> Understand the enabled_by_default property in TheFuck rules. Learn how this boolean flag automatically activates or requires configuration for specific commands, simplifying your workflow.

- Repository: [Vladimir Iakovlev/thefuck](https://github.com/nvbn/thefuck)
- Tags: internals
- Published: 2026-02-27

---

**The `enabled_by_default` property is a boolean flag defined in each rule module that determines whether TheFuck activates the rule automatically or requires explicit user configuration to enable it.**

In the `nvbn/thefuck` repository, every correction rule can declare an `enabled_by_default` attribute that controls its baseline activation state. This property works in tandem with user settings to decide which rules participate when correcting failed shell commands.

## How `enabled_by_default` Controls Rule Activation

The `enabled_by_default` property acts as the rule's "opt-out" flag. When TheFuck loads rule modules, it inspects this attribute to determine the initial state of each rule.

### Rules Enabled by Default

When `enabled_by_default` is `True` or when the attribute is absent from the module, the rule is considered active automatically. Most rules in the repository follow this pattern, ensuring immediate utility after installation.

For example, in [`thefuck/rules/brew_unknown_command.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/rules/brew_unknown_command.py), the property is set dynamically based on system availability:

```python

# thefuck/rules/brew_unknown_command.py

enabled_by_default = brew_available  # → True if Homebrew is present

```

### Rules Disabled by Default

When `enabled_by_default` is explicitly set to `False`, the rule remains inactive unless the user explicitly includes it in their configuration. This pattern protects users from potentially dangerous or niche corrections.

The `git_push_force` rule demonstrates this safety pattern:

```python

# thefuck/rules/git_push_force.py

enabled_by_default = False

```

## The Logic Behind Rule Enablement in [`thefuck/types.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/types.py)

The decision logic for rule activation resides in the `Rule` class within [`thefuck/types.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/types.py). This class encapsulates the `enabled_by_default` attribute and implements the `is_enabled` method that evaluates whether a rule should run.

### Loading the Property from Rule Modules

When TheFuck imports a rule module, the `Rule.from_path` class method extracts the `enabled_by_default` attribute or defaults to `True` if undefined. This occurs in [`thefuck/types.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/types.py), lines 47-53:

```python

# thefuck/types.py (lines 47-53)

return cls(name, rule_module.match,
           rule_module.get_new_command,
           getattr(rule_module, 'enabled_by_default', True),
           getattr(rule_module, 'side_effect', None),
           settings.priority.get(name, priority),
           getattr(rule_module, 'requires_output', True))

```

### Evaluating Rule Status at Runtime

The `is_enabled` method (lines 62-66 in [`thefuck/types.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/types.py)) determines whether a rule participates in the correction process by checking user settings against the `enabled_by_default` flag:

```python

# thefuck/types.py (lines 62-66)

def is_enabled(self):
    """Returns `True` when rule enabled."""
    return (
        self.name in settings.rules
        or self.enabled_by_default
        and ALL_ENABLED in settings.rules
    )

```

This logic ensures that explicit user configuration in `settings.rules` always takes precedence over the default flag.

## Configuration Overrides for `enabled_by_default`

Users can override the `enabled_by_default` property through several configuration mechanisms without modifying the rule source code.

### Using `settings.rules`

Adding a rule name to the `rules` list in your configuration file forces the rule **on**, regardless of its `enabled_by_default` value. To enable the `git_push_force` rule (which defaults to disabled):

```python

# ~/.config/thefuck/settings.py

rules = ['git_push_force', 'apt_get', 'git_commit_amend']

```

### The `ALL_ENABLED` Token

When `settings.rules` contains the special `ALL_ENABLED` token (defined in [`thefuck/const.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/const.py)), TheFuck activates all rules where `enabled_by_default` is `True`, while keeping rules with `False` disabled unless explicitly listed.

```python

# ~/.config/thefuck/settings.py

rules = [ALL_ENABLED, 'git_push_force']  # All defaults + force push rule

```

### Environment Variables

The `THEFUCK_RULES` environment variable provides a command-line override parsed in [`thefuck/conf.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/conf.py) (lines 85-90). This allows temporary activation of disabled rules:

```bash
export THEFUCK_RULES="git_push_force:DEFAULT_RULES"
thefuck <failed command>

```

### Using `exclude_rules`

Conversely, the `exclude_rules` setting overrides `enabled_by_default = True` by explicitly disabling specific rules:

```python

# ~/.config/thefuck/settings.py

exclude_rules = ['apt_get', 'brew_unknown_command']

```

## Practical Examples of `enabled_by_default` in Rules

### Dynamic Default Based on System State

The `brew_unknown_command` rule adjusts its default based on whether Homebrew is installed:

```python

# thefuck/rules/brew_unknown_command.py

import os

brew_available = os.path.exists('/usr/local/bin/brew') or \
                 os.path.exists('/opt/homebrew/bin/brew')

enabled_by_default = brew_available

```

This ensures the rule only activates on systems where it can actually function.

### Safety-Critical Disabled Default

The `git_push_force` rule requires explicit opt-in due to the destructive nature of force pushes:

```python

# thefuck/rules/git_push_force.py

enabled_by_default = False

def match(command):
    return ('git' in command.script and 
            'push' in command.script and 
            'force' in command.script)

def get_new_command(command):
    return command.script.replace('push', 'push --force-with-lease')

```

Users must consciously enable this rule in their settings, preventing accidental data loss.

## Summary

- The `enabled_by_default` property in `thefuck` rules determines whether a rule is active automatically or requires explicit user configuration.
- When set to `True` or undefined, rules activate immediately; when `False`, rules remain inactive unless added to `settings.rules`.
- The `Rule` class in [`thefuck/types.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/types.py) implements this logic through `from_path` (lines 47-53) and `is_enabled` (lines 62-66).
- Users can override defaults via `settings.rules`, the `ALL_ENABLED` token, `exclude_rules`, or the `THEFUCK_RULES` environment variable.

## Frequently Asked Questions

### What happens if a rule doesn't define `enabled_by_default`?

If the `enabled_by_default` attribute is missing from a rule module, TheFuck defaults to treating it as `True`. According to the `Rule.from_path` implementation in [`thefuck/types.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/types.py) (line 50), the code uses `getattr(rule_module, 'enabled_by_default', True)`, ensuring backward compatibility and automatic activation for legacy rules.

### Can I override `enabled_by_default` without editing rule files?

Yes. You can override the default activation state through your user configuration file at `~/.config/thefuck/settings.py` by adding the rule name to the `rules` list (to force enable) or `exclude_rules` list (to force disable). Alternatively, set the `THEFUCK_RULES` environment variable before running the command, as parsed in [`thefuck/conf.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/conf.py) (lines 85-90).

### How does `enabled_by_default` interact with rule priority?

The `enabled_by_default` flag determines whether a rule is considered at all, while the `priority` attribute (set via `settings.priority` or the rule's `priority` variable) determines the execution order among enabled rules. A rule with `enabled_by_default = False` will never run to check its priority unless explicitly enabled in settings, at which point its priority value competes with other active rules.

### Where is the `ALL_ENABLED` constant defined?

The `ALL_ENABLED` sentinel token is defined in [`thefuck/const.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/const.py). When included in your `settings.rules` list, it signals TheFuck to automatically include all rules where `enabled_by_default` is `True`, while excluding those set to `False` unless explicitly listed alongside `ALL_ENABLED`.