diff --git a/mixin-utils/test/Makefile b/mixin-utils/test/Makefile
index ea444b444..153fdabb5 100644
--- a/mixin-utils/test/Makefile
+++ b/mixin-utils/test/Makefile
@@ -4,4 +4,5 @@ vendor jsonnetfile.lock.json: jsonnetfile.json
 	jb install
 
 tests: jsonnetfile.lock.json vendor
-	jsonnet -J vendor/ test_*.libsonnet
+	jsonnet -J vendor/ ./test_native-classic-histogram.libsonnet
+	jsonnet -J vendor/ ./test_remove_rules.libsonnet
diff --git a/mixin-utils/test/test_remove_rules.libsonnet b/mixin-utils/test/test_remove_rules.libsonnet
new file mode 100644
index 000000000..2acb9a6a7
--- /dev/null
+++ b/mixin-utils/test/test_remove_rules.libsonnet
@@ -0,0 +1,284 @@
+local utils = import '../utils.libsonnet';
+local test = import 'github.com/jsonnet-libs/testonnet/main.libsonnet';
+
+local config = {
+  prometheusAlerts: {
+    groups: [
+      {
+        name: 'group1',
+        rules: [
+          {
+            alert: 'alert1',
+          },
+          {
+            alert: 'alert2',
+          },
+        ],
+      },
+      {
+        name: 'group2',
+        rules: [
+          {
+            alert: 'alert3',
+          },
+          {
+            alert: 'alert4',
+          },
+        ],
+      },
+    ],
+  },
+  prometheusRules: {
+    groups: [
+      {
+        name: 'group3',
+        rules: [
+          {
+            record: 'record1',
+          },
+          {
+            record: 'record2',
+          },
+        ],
+      },
+      {
+        name: 'group4',
+        rules: [
+          {
+            record: 'record3',
+          },
+          {
+            record: 'record4',
+          },
+        ],
+      },
+    ],
+  },
+};
+
+test.new(std.thisFile)
+
++ test.case.new(
+  'removeAlertRuleGroup',
+  test.expect.eq(
+    actual=config + utils.removeAlertRuleGroup('group1'),
+    expected={
+      prometheusAlerts: {
+        groups: [
+          {
+            name: 'group2',
+            rules: [
+              {
+                alert: 'alert3',
+              },
+              {
+                alert: 'alert4',
+              },
+            ],
+          },
+        ],
+      },
+      prometheusRules: {
+        groups: [
+          {
+            name: 'group3',
+            rules: [
+              {
+                record: 'record1',
+              },
+              {
+                record: 'record2',
+              },
+            ],
+          },
+          {
+            name: 'group4',
+            rules: [
+              {
+                record: 'record3',
+              },
+              {
+                record: 'record4',
+              },
+            ],
+          },
+        ],
+      },
+    }
+  )
+)
+
++ test.case.new(
+  'removeRecordingRuleGroup',
+  test.expect.eq(
+    actual=config + utils.removeRecordingRuleGroup('group4'),
+    expected={
+      prometheusAlerts: {
+        groups: [
+          {
+            name: 'group1',
+            rules: [
+              {
+                alert: 'alert1',
+              },
+              {
+                alert: 'alert2',
+              },
+            ],
+          },
+          {
+            name: 'group2',
+            rules: [
+              {
+                alert: 'alert3',
+              },
+              {
+                alert: 'alert4',
+              },
+            ],
+          },
+        ],
+      },
+      prometheusRules: {
+        groups: [
+          {
+            name: 'group3',
+            rules: [
+              {
+                record: 'record1',
+              },
+              {
+                record: 'record2',
+              },
+            ],
+          },
+        ],
+      },
+    }
+  )
+)
+
++ test.case.new(
+  'removeAlertRuleGroup with groupname from recording rules (noop)',
+  test.expect.eq(
+    actual=config + utils.removeAlertRuleGroup('group4'),
+    expected=config
+  )
+)
++ test.case.new(
+  'removeRecordingRuleGroup with groupname from alert rules (noop)',
+  test.expect.eq(
+    actual=config + utils.removeRecordingRuleGroup('group2'),
+    expected=config
+  )
+)
+
++ test.case.new(
+  'removeAlerts',
+  test.expect.eq(
+    actual=config + utils.removeAlerts(['alert1', 'alert4']),
+    expected={
+      prometheusAlerts: {
+        groups: [
+          {
+            name: 'group1',
+            rules: [
+              {
+                alert: 'alert2',
+              },
+            ],
+          },
+          {
+            name: 'group2',
+            rules: [
+              {
+                alert: 'alert3',
+              },
+            ],
+          },
+        ],
+      },
+      prometheusRules: {
+        groups: [
+          {
+            name: 'group3',
+            rules: [
+              {
+                record: 'record1',
+              },
+              {
+                record: 'record2',
+              },
+            ],
+          },
+          {
+            name: 'group4',
+            rules: [
+              {
+                record: 'record3',
+              },
+              {
+                record: 'record4',
+              },
+            ],
+          },
+        ],
+      },
+    }
+  )
+)
+
++ test.case.new(
+  'removeAlerts - object (backwards compatible)',
+  test.expect.eq(
+    actual=config + utils.removeAlerts({ alert1: {}, alert4: {} }),
+    expected={
+      prometheusAlerts: {
+        groups: [
+          {
+            name: 'group1',
+            rules: [
+              {
+                alert: 'alert2',
+              },
+            ],
+          },
+          {
+            name: 'group2',
+            rules: [
+              {
+                alert: 'alert3',
+              },
+            ],
+          },
+        ],
+      },
+      prometheusRules: {
+        groups: [
+          {
+            name: 'group3',
+            rules: [
+              {
+                record: 'record1',
+              },
+              {
+                record: 'record2',
+              },
+            ],
+          },
+          {
+            name: 'group4',
+            rules: [
+              {
+                record: 'record3',
+              },
+              {
+                record: 'record4',
+              },
+            ],
+          },
+        ],
+      },
+    }
+  )
+)
diff --git a/mixin-utils/utils.libsonnet b/mixin-utils/utils.libsonnet
index 7eabb5f0f..f94d34614 100644
--- a/mixin-utils/utils.libsonnet
+++ b/mixin-utils/utils.libsonnet
@@ -392,18 +392,16 @@ local g = import 'grafana-builder/grafana.libsonnet';
       for group in groups
     ],
 
-  removeRuleGroup(ruleName):: {
-    local removeRuleGroup(rule) = if rule.name == ruleName then null else rule,
-    local currentRuleGroups = super.groups,
-    groups: std.prune(std.map(removeRuleGroup, currentRuleGroups)),
+  removeRuleGroup(groupName):: {
+    groups: std.filter(function(group) group.name != groupName, super.groups),
   },
 
   removeAlertRuleGroup(ruleName):: {
-    prometheusAlerts+:: $.removeRuleGroup(ruleName),
+    prometheusAlerts+: $.removeRuleGroup(ruleName),
   },
 
   removeRecordingRuleGroup(ruleName):: {
-    prometheusRules+:: $.removeRuleGroup(ruleName),
+    prometheusRules+: $.removeRuleGroup(ruleName),
   },
 
   overrideAlerts(overrides):: {
@@ -412,19 +410,20 @@ local g = import 'grafana-builder/grafana.libsonnet';
       then rule + overrides[rule.alert]
       else rule,
     local overrideInGroup(group) = group { rules: std.map(overrideRule, super.rules) },
-    prometheusAlerts+:: {
+    prometheusAlerts+: {
       groups: std.map(overrideInGroup, super.groups),
     },
   },
 
   removeAlerts(alerts):: {
-    local removeRule(rule) =
-      if 'alert' in rule && std.objectHas(alerts, rule.alert)
-      then {}
-      else rule,
-    local removeInGroup(group) = group { rules: std.map(removeRule, super.rules) },
-    prometheusAlerts+:: {
-      groups: std.prune(std.map(removeInGroup, super.groups)),
+    local alertNames =
+      if std.isObject(alerts)
+      then std.objectFields(alerts)
+      else alerts,
+    local removeRule(rule) = !std.member(alertNames, std.get(rule, 'alert', '')),
+    local removeInGroup(group) = group { rules: std.filter(removeRule, super.rules) },
+    prometheusAlerts+: {
+      groups: std.map(removeInGroup, super.groups),
     },
   },
 }