diff --git a/esbuild.config.mjs b/esbuild.config.mjs
index 4697ae9f..bb77bbf5 100644
--- a/esbuild.config.mjs
+++ b/esbuild.config.mjs
@@ -25,7 +25,7 @@ const mockedPlugins = [replace({
     // update usage of moment from obsidian to the node implementation of moment we have
     'import {moment} from \'obsidian\';': 'import moment from \'moment\';',
     // remove the use of obsidian in the options to allow for docs.js to run
-    'import {Setting} from \'obsidian\';': '',
+    'import {App, Setting, ToggleComponent} from \'obsidian\';': '',
     // remove the use of obsidian in settings helper to allow for docs.js to run
     'import {App, MarkdownRenderer} from \'obsidian\';': '',
     // remove the use of obsidian in the auto-correct files picker to allow for docs.js to run
@@ -38,6 +38,8 @@ const mockedPlugins = [replace({
     'import {App, TFile} from \'obsidian\';': '',
     // remove the use of obsidian in parse results modal to allow for docs.js to run
     'import {Modal, App} from \'obsidian\';': 'class Modal {}',
+    // remove the use of app from a couple of settings for docs.js to run
+    'import {App} from \'obsidian\';': '',
   },
   delimiters: ['', ''],
 })];
diff --git a/src/lang/locale/en.ts b/src/lang/locale/en.ts
index 2d2fd113..75b9ecd2 100644
--- a/src/lang/locale/en.ts
+++ b/src/lang/locale/en.ts
@@ -111,6 +111,12 @@ export default {
 
   'copy-aria-label': 'Copy',
 
+  'disabled-other-rule-notice': 'If you enable <code>{NAME_1}</code>, it will disable <code>{NAME_2}</code>. Would you like to proceed?',
+  'disabled-conflicting-rule-notice': '{NAME_1}, conflicts with {NAME_2}, so it has been turned off. You can switch which setting is off in the settings tab.',
+
+  // confirm-rule-disable-modal.ts
+  'ok': 'Ok',
+
   // parse-results-modal.ts
   'parse-results-heading-text': 'Custom Parse Values',
   'file-parse-description-text': 'The following is the list of custom replacements found in {FILE}.',
diff --git a/src/main.ts b/src/main.ts
index 78877fe5..0e5fe9da 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -129,69 +129,13 @@ export default class LinterPlugin extends Plugin {
     setLogLevel(this.settings.logLevel);
     await this.setOrUpdateMomentInstance();
 
-    let updateMade = false;
-    if (!this.settings.settingsConvertedToConfigKeyValues) {
-      updateMade = await this.moveConfigValuesToKeyBasedFormat();
-    }
-
-    if ('lintOnFileContentChangeDelay' in this.settings) {
-      this.settings.ruleConfigs['yaml-timestamp']['update-on-file-contents-updated'] = this.settings['lintOnFileContentChangeDelay'];
-
-      delete this.settings['lintOnFileContentChangeDelay'];
-      updateMade = true;
-    }
-
-    // make sure to load the defaults of any missing rules to make sure they do not cause issues on the settings page
-    for (const rule of rules) {
-      if (!this.settings.ruleConfigs[rule.alias]) {
-        this.settings.ruleConfigs[rule.alias] = rule.getDefaultOptions();
-      }
-
-      // remove this after a reasonable amount of time
-      if (rule.alias == 'space-between-chinese-japanese-or-korean-and-english-or-numbers') {
-        const defaults = rule.getDefaultOptions();
-        if (!('english-symbols-punctuation-before' in this.settings.ruleConfigs[rule.alias])) {
-          this.settings.ruleConfigs[rule.alias]['english-symbols-punctuation-before'] = defaults['english-symbols-punctuation-before'];
-          updateMade = true;
-        }
-
-        if (!('english-symbols-punctuation-after' in this.settings.ruleConfigs[rule.alias])) {
-          this.settings.ruleConfigs[rule.alias]['english-symbols-punctuation-after'] = defaults['english-symbols-punctuation-after'];
-          updateMade = true;
-        }
-      } else if (rule.alias == 'yaml-timestamp') {
-        const defaults = rule.getDefaultOptions();
-        if ('force-retention-of-create-value' in this.settings.ruleConfigs[rule.alias]) {
-          if (!('date-created-source-of-truth' in this.settings.ruleConfigs[rule.alias])) {
-            if (this.settings.ruleConfigs[rule.alias]['force-retention-of-create-value']) {
-              this.settings.ruleConfigs[rule.alias]['date-created-source-of-truth'] = 'frontmatter';
-            } else {
-              this.settings.ruleConfigs[rule.alias]['date-created-source-of-truth'] = defaults['date-created-source-of-truth'];
-            }
-          }
-
-          delete this.settings.ruleConfigs[rule.alias]['force-retention-of-create-value'];
-          updateMade = true;
-        }
-
-        if (!('date-modified-source-of-truth' in this.settings.ruleConfigs[rule.alias])) {
-          this.settings.ruleConfigs[rule.alias]['date-modified-source-of-truth'] = defaults['date-modified-source-of-truth'];
-          updateMade = true;
-        }
-      }
-    }
-
     this.updatePasteOverrideStatus();
     this.updateHasCustomCommandStatus();
-
-    if (updateMade) {
-      await this.saveSettings();
-    }
   }
 
   async saveSettings() {
     if (!this.hasLoadedMisspellingFiles) {
-      await this.loadAutoCorrectFiles();
+      await this.loadAutoCorrectFiles(false);
     }
 
     await this.saveData(this.settings);
@@ -328,7 +272,8 @@ export default class LinterPlugin extends Plugin {
     this.eventRefs.push(eventRef);
 
     this.app.workspace.onLayoutReady(async () => {
-      await this.loadAutoCorrectFiles();
+      await this.makeSureSettingsFilledInAndCleanupSettings();
+      await this.loadAutoCorrectFiles(true);
     });
 
     // Source for save setting
@@ -375,13 +320,17 @@ export default class LinterPlugin extends Plugin {
     }
   }
 
-  async loadAutoCorrectFiles() {
+  async loadAutoCorrectFiles(isOnload: boolean) {
     const customAutoCorrectSettings = this.settings.ruleConfigs['auto-correct-common-misspellings'];
     if (!customAutoCorrectSettings || !customAutoCorrectSettings.enabled) {
       return;
     }
 
     await downloadMisspellings(this, async (message: string) => {
+      if (isOnload) {
+        message = 'Obsidian Linter:\n' + message;
+      }
+
       new Notice(message);
 
       this.settings.ruleConfigs['auto-correct-common-misspellings'].enabled = false;
@@ -619,6 +568,109 @@ export default class LinterPlugin extends Plugin {
     moment.locale(oldLocale);
   }
 
+  private async makeSureSettingsFilledInAndCleanupSettings() {
+    let updateMade = false;
+
+    // migrate settings over to the new format if they are using the now deprecated format that uses
+    // actual settings names for the key in the json
+    if (!this.settings.settingsConvertedToConfigKeyValues) {
+      updateMade = await this.moveConfigValuesToKeyBasedFormat();
+    }
+
+    // move a recently moved setting to its new location
+    if ('lintOnFileContentChangeDelay' in this.settings) {
+      this.settings.ruleConfigs['yaml-timestamp']['update-on-file-contents-updated'] = this.settings['lintOnFileContentChangeDelay'];
+
+      delete this.settings['lintOnFileContentChangeDelay'];
+      updateMade = true;
+    }
+
+    // check for and fix invalid settings
+    let noticeText = 'Obsidian Linter:';
+    let conflictingRulePresent = false;
+    if (this.settings.ruleConfigs['header-increment'] && this.settings.ruleConfigs['header-increment'].enabled && this.settings.ruleConfigs['header-increment']['start-at-h2'] &&
+      this.settings.ruleConfigs['file-name-heading'] && this.settings.ruleConfigs['file-name-heading'].enabled
+    ) {
+      this.settings.ruleConfigs['header-increment']['start-at-h2'] = false;
+      updateMade = true;
+      conflictingRulePresent = true;
+
+      noticeText += '\n' + getTextInLanguage('disabled-conflicting-rule-notice').replace('{NAME_1}', getTextInLanguage('rules.header-increment.start-at-h2.name')).replace('{NAME_2}', getTextInLanguage('rules.file-name-heading.name'));
+    }
+
+    if (this.settings.ruleConfigs['paragraph-blank-lines'] && this.settings.ruleConfigs['paragraph-blank-lines'].enabled &&
+      this.settings.ruleConfigs['two-spaces-between-lines-with-content'] && this.settings.ruleConfigs['two-spaces-between-lines-with-content'].enabled
+    ) {
+      this.settings.ruleConfigs['paragraph-blank-lines'].enabled = false;
+      updateMade = true;
+
+      if (conflictingRulePresent) {
+        noticeText += '\n';
+      }
+      conflictingRulePresent = true;
+
+      noticeText += '\n' + getTextInLanguage('disabled-conflicting-rule-notice').replace('{NAME_1}', getTextInLanguage('rules.paragraph-blank-lines.name')).replace('{NAME_2}', getTextInLanguage('rules.two-spaces-between-lines-with-content.name'));
+    }
+
+    if (conflictingRulePresent) {
+      new Notice(noticeText, userClickTimeout);
+    }
+
+    // make sure to load the defaults of any missing rules to make sure they do not cause issues on the settings page
+    for (const rule of rules) {
+      const ruleDefaults = rule.getDefaultOptions();
+      if (!this.settings.ruleConfigs[rule.alias]) {
+        this.settings.ruleConfigs[rule.alias] = ruleDefaults;
+        updateMade = true;
+        continue;
+      }
+
+      // remove this after a reasonable amount of time
+      if (rule.alias == 'space-between-chinese-japanese-or-korean-and-english-or-numbers') {
+        if (!('english-symbols-punctuation-before' in this.settings.ruleConfigs[rule.alias])) {
+          this.settings.ruleConfigs[rule.alias]['english-symbols-punctuation-before'] = ruleDefaults['english-symbols-punctuation-before'];
+          updateMade = true;
+        }
+
+        if (!('english-symbols-punctuation-after' in this.settings.ruleConfigs[rule.alias])) {
+          this.settings.ruleConfigs[rule.alias]['english-symbols-punctuation-after'] = ruleDefaults['english-symbols-punctuation-after'];
+          updateMade = true;
+        }
+      } else if (rule.alias == 'yaml-timestamp') {
+        const defaults = rule.getDefaultOptions();
+        if ('force-retention-of-create-value' in this.settings.ruleConfigs[rule.alias]) {
+          if (!('date-created-source-of-truth' in this.settings.ruleConfigs[rule.alias])) {
+            if (this.settings.ruleConfigs[rule.alias]['force-retention-of-create-value']) {
+              this.settings.ruleConfigs[rule.alias]['date-created-source-of-truth'] = 'frontmatter';
+            } else {
+              this.settings.ruleConfigs[rule.alias]['date-created-source-of-truth'] = defaults['date-created-source-of-truth'];
+            }
+          }
+
+          delete this.settings.ruleConfigs[rule.alias]['force-retention-of-create-value'];
+          updateMade = true;
+        }
+
+        if (!('date-modified-source-of-truth' in this.settings.ruleConfigs[rule.alias])) {
+          this.settings.ruleConfigs[rule.alias]['date-modified-source-of-truth'] = defaults['date-modified-source-of-truth'];
+          updateMade = true;
+        }
+      }
+
+      // make sure new/empty settings on a rule that exists get filled in with their default value as well
+      for (const key of Object.keys(ruleDefaults)) {
+        if (!Object.hasOwn(this.settings.ruleConfigs[rule.alias], key)) {
+          this.settings.ruleConfigs[rule.alias][key] = ruleDefaults[key];
+          updateMade = true;
+        }
+      }
+    }
+
+    if (updateMade) {
+      await this.saveSettings();
+    }
+  }
+
   private createDebouncedFileUpdate(): Debouncer<[TFile, Editor], Promise<void>> {
     let delay = 5000;
     switch (this.settings.ruleConfigs['yaml-timestamp']['update-on-file-contents-updated'] ?? AfterFileChangeLintTimes.Never) {
diff --git a/src/option.ts b/src/option.ts
index b02e018b..2d49c0d3 100644
--- a/src/option.ts
+++ b/src/option.ts
@@ -1,4 +1,4 @@
-import {Setting} from 'obsidian';
+import {App, Setting, ToggleComponent} from 'obsidian';
 import {getTextInLanguage, LanguageStringKey} from './lang/helpers';
 import LinterPlugin from './main';
 import {hideEl, unhideEl, setElContent} from './ui/helpers';
@@ -63,21 +63,24 @@ export abstract class Option {
 
 export class BooleanOption extends Option {
   public defaultValue: boolean;
+  private toggleComponent: ToggleComponent;
 
-  constructor(configKey: string, nameKey: LanguageStringKey, descriptionKey: LanguageStringKey, defaultValue: any, ruleAlias?: string | null, private onChange?: (value: boolean) => void) {
+  constructor(configKey: string, nameKey: LanguageStringKey, descriptionKey: LanguageStringKey, defaultValue: any, ruleAlias?: string | null, private onChange?: (value: boolean, app: App) => void) {
     super(configKey, nameKey, descriptionKey, defaultValue, ruleAlias);
   }
 
   public display(containerEl: HTMLElement, settings: LinterSettings, plugin: LinterPlugin): void {
     this.setting = new Setting(containerEl)
         .addToggle((toggle) => {
+          this.toggleComponent = toggle;
+
           toggle.setValue(settings.ruleConfigs[this.ruleAlias][this.configKey]);
           toggle.onChange((value) => {
             this.setOption(value, settings);
             plugin.settings = settings;
 
             if (this.onChange) {
-              this.onChange(value);
+              this.onChange(value, plugin.app);
             }
 
             void plugin.saveSettings();
@@ -86,6 +89,14 @@ export class BooleanOption extends Option {
 
     this.parseNameAndDescriptionAndRemoveSettingBorder();
   }
+
+  getValue(): boolean {
+    return this.toggleComponent.getValue();
+  }
+
+  setValue(value: boolean) {
+    this.toggleComponent.setValue(value);
+  }
 }
 
 export class TextOption extends Option {
diff --git a/src/rules.ts b/src/rules.ts
index 87c70dd9..754d89fc 100644
--- a/src/rules.ts
+++ b/src/rules.ts
@@ -11,6 +11,7 @@ import {LinterError} from './linter-error';
 import {getTextInLanguage, LanguageStringKey} from './lang/helpers';
 import {ignoreListOfTypes, IgnoreType} from './utils/ignore-types';
 import {LinterSettings} from './settings-data';
+import {App} from 'obsidian';
 
 export type Options = { [optionName: string]: any};
 
@@ -41,6 +42,7 @@ export class Rule {
    * @param {Array<Option>} [options=[]] - The options of the rule to be displayed in the documentation
    * @param {boolean} [hasSpecialExecutionOrder=false] - The rule has special execution order
    * @param {IgnoreType[]} [ignoreTypes=[]] - The types of elements to ignore for the rule
+   * @param {function(boolean):boolean} [disableConflictingOptions=null] - The function to disable conflicting rules or options when it is enabled
    */
   constructor(
       private nameKey: LanguageStringKey,
@@ -53,10 +55,15 @@ export class Rule {
       public options: Array<Option> = [],
       public readonly hasSpecialExecutionOrder: boolean = false,
       public readonly ignoreTypes: IgnoreType[] = [],
+      disableConflictingOptions: (value: boolean, app: App) => void = null,
   ) {
     this.ruleHeading = this.getName().toLowerCase().replaceAll(' ', '-');
 
-    options.unshift(new BooleanOption('enabled', this.descriptionKey, '' as LanguageStringKey, false, alias, (value: boolean) => {
+    options.unshift(new BooleanOption('enabled', this.descriptionKey, '' as LanguageStringKey, false, alias, (value: boolean, app: App) => {
+      if (value && disableConflictingOptions) {
+        disableConflictingOptions(value, app);
+      }
+
       if (options.length > 1) {
         for (let i = 1; i < options.length; i++) {
           if (value) {
diff --git a/src/rules/file-name-heading.ts b/src/rules/file-name-heading.ts
index 212eece0..31c43ae7 100644
--- a/src/rules/file-name-heading.ts
+++ b/src/rules/file-name-heading.ts
@@ -1,8 +1,11 @@
-import {Options, RuleType} from '../rules';
+import {Options, rulesDict, RuleType} from '../rules';
 import RuleBuilder, {ExampleBuilder, OptionBuilderBase} from './rule-builder';
 import dedent from 'ts-dedent';
 import {IgnoreTypes} from '../utils/ignore-types';
 import {insert} from '../utils/strings';
+import {App} from 'obsidian';
+import {BooleanOption} from '../option';
+import {ConfirmRuleDisableModal} from '../ui/modals/confirm-rule-disable-modal';
 
 class FileNameHeadingOptions implements Options {
   @RuleBuilder.noSettingControl()
@@ -17,6 +20,19 @@ export default class FileNameHeading extends RuleBuilder<FileNameHeadingOptions>
       descriptionKey: 'rules.file-name-heading.description',
       type: RuleType.HEADING,
       ruleIgnoreTypes: [IgnoreTypes.code, IgnoreTypes.math, IgnoreTypes.yaml, IgnoreTypes.link, IgnoreTypes.wikiLink, IgnoreTypes.tag],
+      disableConflictingOptions(value: boolean, app: App): void {
+        const headerIncrementOptions = rulesDict['header-increment'];
+        const headerIncrementEnableOption = headerIncrementOptions.options[0] as BooleanOption;
+        const headerIncrementStartAtH2Option = headerIncrementOptions.options[1] as BooleanOption;
+        if (value && headerIncrementEnableOption.getValue()) {
+          new ConfirmRuleDisableModal(app, 'rules.file-name-heading.name', 'rules.header-increment.start-at-h2.name', () => {
+            headerIncrementStartAtH2Option.setValue(false);
+          },
+          () => {
+            (rulesDict['file-name-heading'].options[0] as BooleanOption).setValue(false);
+          }).open();
+        }
+      },
     });
   }
   get OptionsClass(): new () => FileNameHeadingOptions {
diff --git a/src/rules/header-increment.ts b/src/rules/header-increment.ts
index 8aca0d28..9b58f23f 100644
--- a/src/rules/header-increment.ts
+++ b/src/rules/header-increment.ts
@@ -1,8 +1,11 @@
-import {Options, RuleType} from '../rules';
+import {Options, rulesDict, RuleType} from '../rules';
 import RuleBuilder, {BooleanOptionBuilder, ExampleBuilder, OptionBuilderBase} from './rule-builder';
 import dedent from 'ts-dedent';
 import {IgnoreTypes} from '../utils/ignore-types';
 import {allHeadersRegex} from '../utils/regex';
+import {BooleanOption} from '../option';
+import {ConfirmRuleDisableModal} from '../ui/modals/confirm-rule-disable-modal';
+import {App} from 'obsidian';
 
 class HeaderIncrementOptions implements Options {
   startAtH2?: boolean = false;
@@ -169,6 +172,18 @@ export default class HeaderIncrement extends RuleBuilder<HeaderIncrementOptions>
         nameKey: 'rules.header-increment.start-at-h2.name',
         descriptionKey: 'rules.header-increment.start-at-h2.description',
         optionsKey: 'startAtH2',
+        onChange(value: boolean, app: App): void {
+          const filenameHeadingEnableOption = rulesDict['file-name-heading'].options[0] as BooleanOption;
+
+          if (value && filenameHeadingEnableOption.getValue()) {
+            new ConfirmRuleDisableModal(app, 'rules.header-increment.start-at-h2.name', 'rules.file-name-heading.name', () => {
+              filenameHeadingEnableOption.setValue(false);
+            },
+            () => {
+              (rulesDict['header-increment'].options[1] as BooleanOption).setValue(false);
+            }).open();
+          }
+        },
       }),
     ];
   }
diff --git a/src/rules/paragraph-blank-lines.ts b/src/rules/paragraph-blank-lines.ts
index d5acc901..8f44d4fc 100644
--- a/src/rules/paragraph-blank-lines.ts
+++ b/src/rules/paragraph-blank-lines.ts
@@ -1,8 +1,11 @@
 import {IgnoreTypes} from '../utils/ignore-types';
 import {makeSureThereIsOnlyOneBlankLineBeforeAndAfterParagraphs} from '../utils/mdast';
-import {Options, RuleType} from '../rules';
+import {Options, rulesDict, RuleType} from '../rules';
 import RuleBuilder, {ExampleBuilder, OptionBuilderBase} from './rule-builder';
 import dedent from 'ts-dedent';
+import {BooleanOption} from '../option';
+import {ConfirmRuleDisableModal} from '../ui/modals/confirm-rule-disable-modal';
+import {App} from 'obsidian';
 
 class ParagraphBlankLinesOptions implements Options {}
 
@@ -14,6 +17,17 @@ export default class ParagraphBlankLines extends RuleBuilder<ParagraphBlankLines
       descriptionKey: 'rules.paragraph-blank-lines.description',
       type: RuleType.SPACING,
       ruleIgnoreTypes: [IgnoreTypes.obsidianMultiLineComments, IgnoreTypes.yaml, IgnoreTypes.table],
+      disableConflictingOptions(value: boolean, app: App): void {
+        const twoSpacesEnableOption = rulesDict['two-spaces-between-lines-with-content'].options[0] as BooleanOption;
+        if (value && twoSpacesEnableOption.getValue()) {
+          new ConfirmRuleDisableModal(app, 'rules.paragraph-blank-lines.name', 'rules.two-spaces-between-lines-with-content.name', () => {
+            twoSpacesEnableOption.setValue(false);
+          },
+          () => {
+            (rulesDict['paragraph-blank-lines'].options[0] as BooleanOption).setValue(false);
+          }).open();
+        }
+      },
     });
   }
   get OptionsClass(): new () => ParagraphBlankLinesOptions {
diff --git a/src/rules/rule-builder.ts b/src/rules/rule-builder.ts
index 0de03833..62b33476 100644
--- a/src/rules/rule-builder.ts
+++ b/src/rules/rule-builder.ts
@@ -4,6 +4,7 @@ import {logDebug, timingBegin, timingEnd} from '../utils/logger';
 import {getTextInLanguage, LanguageStringKey} from '../lang/helpers';
 import {IgnoreType, IgnoreTypes} from '../utils/ignore-types';
 import {LinterSettings} from 'src/settings-data';
+import {App} from 'obsidian';
 
 export abstract class RuleBuilderBase {
   static #ruleMap = new Map<string, Rule>();
@@ -13,7 +14,7 @@ export abstract class RuleBuilderBase {
   static getRule<TOptions extends Options>(this: (new() => RuleBuilder<TOptions>)): Rule {
     if (!RuleBuilderBase.#ruleMap.has(this.name)) {
       const builder = new this();
-      const rule = new Rule(builder.nameKey, builder.descriptionKey, builder.settingsKey, builder.alias, builder.type, builder.safeApply.bind(builder), builder.exampleBuilders.map((b) => b.example), builder.optionBuilders.map((b) => b.option), builder.hasSpecialExecutionOrder, builder.ignoreTypes);
+      const rule = new Rule(builder.nameKey, builder.descriptionKey, builder.settingsKey, builder.alias, builder.type, builder.safeApply.bind(builder), builder.exampleBuilders.map((b) => b.example), builder.optionBuilders.map((b) => b.option), builder.hasSpecialExecutionOrder, builder.ignoreTypes, builder.disableConflictingOptions);
       RuleBuilderBase.#ruleMap.set(this.name, rule);
       RuleBuilderBase.#ruleBuilderMap.set(builder.alias, builder);
     }
@@ -67,6 +68,7 @@ type RuleBuilderConstructorArgs = {
   // ignore types to use on the entirety of the rule and not just a part
   // Note: this value should not contain custom ignore as that is added to all rules except Paste rules which do not use this property
   ruleIgnoreTypes?: IgnoreType[],
+  disableConflictingOptions?: (value: boolean, app: App) => void,
 };
 
 export default abstract class RuleBuilder<TOptions extends Options> extends RuleBuilderBase {
@@ -77,6 +79,7 @@ export default abstract class RuleBuilder<TOptions extends Options> extends Rule
   public type: RuleType;
   public hasSpecialExecutionOrder: boolean;
   public ignoreTypes: IgnoreType[];
+  public disableConflictingOptions: (value: boolean, app: App) => void;
   constructor(args: RuleBuilderConstructorArgs) {
     super();
 
@@ -87,6 +90,7 @@ export default abstract class RuleBuilder<TOptions extends Options> extends Rule
     this.descriptionKey = args.descriptionKey;
     this.type = args.type;
     this.hasSpecialExecutionOrder = args.hasSpecialExecutionOrder ?? false;
+    this.disableConflictingOptions = args.disableConflictingOptions ?? null;
 
     if (args.ruleIgnoreTypes) {
       this.ignoreTypes = [IgnoreTypes.customIgnore, ...args.ruleIgnoreTypes];
@@ -226,8 +230,16 @@ export abstract class OptionBuilder<TOptions extends Options, TValue> {
 }
 
 export class BooleanOptionBuilder<TOptions extends Options> extends OptionBuilder<TOptions, boolean> {
+  onChange?: (value: boolean, app: App) => void;
+  constructor(args: OptionBuilderConstructorArgs<TOptions, boolean> & {
+    onChange?: (value: boolean, app: App) => void,
+  }) {
+    super(args);
+    this.onChange = args.onChange ?? null;
+  }
+
   protected buildOption(): Option {
-    return new BooleanOption(this.configKey, this.nameKey, this.descriptionKey, this.defaultValue);
+    return new BooleanOption(this.configKey, this.nameKey, this.descriptionKey, this.defaultValue, null, this.onChange);
   }
 }
 
diff --git a/src/rules/two-spaces-between-lines-with-content.ts b/src/rules/two-spaces-between-lines-with-content.ts
index c46df118..4e44d60e 100644
--- a/src/rules/two-spaces-between-lines-with-content.ts
+++ b/src/rules/two-spaces-between-lines-with-content.ts
@@ -1,8 +1,11 @@
-import {Options, RuleType} from '../rules';
+import {Options, rulesDict, RuleType} from '../rules';
 import RuleBuilder, {DropdownOptionBuilder, ExampleBuilder, OptionBuilderBase} from './rule-builder';
 import dedent from 'ts-dedent';
 import {IgnoreTypes} from '../utils/ignore-types';
 import {LineBreakIndicators, addTwoSpacesAtEndOfLinesFollowedByAnotherLineOfTextContent} from '../utils/mdast';
+import {BooleanOption} from '../option';
+import {ConfirmRuleDisableModal} from '../ui/modals/confirm-rule-disable-modal';
+import {App} from 'obsidian';
 
 class TwoSpacesBetweenLinesWithContentOptions implements Options {
   lineBreakIndicator?: LineBreakIndicators = LineBreakIndicators.TwoSpaces;
@@ -16,6 +19,17 @@ export default class TwoSpacesBetweenLinesWithContent extends RuleBuilder<TwoSpa
       descriptionKey: 'rules.two-spaces-between-lines-with-content.description',
       type: RuleType.CONTENT,
       ruleIgnoreTypes: [IgnoreTypes.obsidianMultiLineComments, IgnoreTypes.yaml, IgnoreTypes.table],
+      disableConflictingOptions(value: boolean, app: App): void {
+        const paragraphBlankLinesEnableOption = rulesDict['paragraph-blank-lines'].options[0] as BooleanOption;
+        if (value && paragraphBlankLinesEnableOption.getValue()) {
+          new ConfirmRuleDisableModal(app, 'rules.paragraph-blank-lines.name', 'rules.two-spaces-between-lines-with-content.name', () => {
+            paragraphBlankLinesEnableOption.setValue(false);
+          },
+          () => {
+            (rulesDict['two-spaces-between-lines-with-content'].options[0] as BooleanOption).setValue(false);
+          }).open();
+        }
+      },
     });
   }
   get OptionsClass(): new () => TwoSpacesBetweenLinesWithContentOptions {
diff --git a/src/styles.css b/src/styles.css
index 9d41a4f7..a7ca7c53 100644
--- a/src/styles.css
+++ b/src/styles.css
@@ -41,7 +41,7 @@
   }
 }
 
-.linter-navigation-item-icon {
+.linter-navigation-item-icon, .linter-warning {
   padding-top: 5px;
 }
 
@@ -269,3 +269,4 @@ textarea.full-width {
 .modal-heading, .search-zero-state {
   text-align: center;
 }
+
diff --git a/src/ui/modals/confirm-rule-disable-modal.ts b/src/ui/modals/confirm-rule-disable-modal.ts
new file mode 100644
index 00000000..0c8327ae
--- /dev/null
+++ b/src/ui/modals/confirm-rule-disable-modal.ts
@@ -0,0 +1,38 @@
+import {Modal, App} from 'obsidian';
+import {getTextInLanguage, LanguageStringKey} from '../../lang/helpers';
+import {setElContent} from '../helpers';
+
+// https://github.com/nothingislost/obsidian-workspaces-plus/blob/bbba928ec64b30b8dec7fe8fc9e5d2d96543f1f3/src/modal.ts#L68
+export class ConfirmRuleDisableModal extends Modal {
+  constructor(app: App, ruleBeingEnabledName: LanguageStringKey, ruleBeingDisabledName: LanguageStringKey, btnSubmitAction: () => void, btnCancelAction: () => void) {
+    super(app);
+    this.modalEl.addClass('confirm-modal');
+
+    this.contentEl.createEl('h3', {text: getTextInLanguage('warning-text'), cls: 'modal-heading'});
+
+    const noticeEl = this.contentEl.createEl('p');
+    noticeEl.id = 'confirm-dialog';
+
+    setElContent(getTextInLanguage('disabled-other-rule-notice').replace('{NAME_1}', getTextInLanguage(ruleBeingEnabledName)).replace('{NAME_2}', getTextInLanguage(ruleBeingDisabledName)), noticeEl);
+
+    this.contentEl.createDiv('modal-button-container', (buttonsEl) => {
+      buttonsEl.createEl('button', {text: getTextInLanguage('cancel-button-text')}).addEventListener('click', () => {
+        btnCancelAction();
+        this.close();
+      });
+
+      const btnSubmit = buttonsEl.createEl('button', {
+        attr: {type: 'submit'},
+        cls: 'mod-cta',
+        text: getTextInLanguage('ok'),
+      });
+      btnSubmit.addEventListener('click', () => {
+        this.close();
+        btnSubmitAction();
+      });
+      setTimeout(() => {
+        btnSubmit.focus();
+      }, 50);
+    });
+  }
+}