diff --git a/CHANGELOG.md b/CHANGELOG.md
index cc65b385..10603f4b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+* Introduce Y091, which warns if `Callable[<parameter_list>, Any]` or
+  `Callable[<parameter_list>, None]` is used as an argument annotation in a
+  function or method. Most of the time, the returned object from callbacks like
+  these is ignored at runtime, so the annotation you're probably looking for is
+  `Callable[<parameter_list>, object]`.
+
+  This error code is disabled by default due to the risk of false-positive
+  errors. To enable it, use the `--extend-select=Y091` option.
 * The undocumented `pyi.__version__` and `pyi.PyiTreeChecker.version`
   attributes has been removed. Use `flake8 --version` from the command line, or
   `importlib.metadata.version("flake8_pyi")` at runtime, to determine the
diff --git a/ERRORCODES.md b/ERRORCODES.md
index 7a06c6b2..673d075f 100644
--- a/ERRORCODES.md
+++ b/ERRORCODES.md
@@ -75,3 +75,4 @@ recommend only using `--extend-select`, never `--select`.
 | Code | Description
 |------|------------
 | Y090 | `tuple[int]` means "a tuple of length 1, in which the sole element is of type `int`". Consider using `tuple[int, ...]` instead, which means "a tuple of arbitrary (possibly 0) length, in which all elements are of type `int`".
+| Y091 | `Callable[<parameter_list>, None]` or `Callable[<parameter_list>, Any]` is generally a mistake in the context of a parameter annotation for a function or method. The returned value from a callback is generally ignored at runtime, so `Callable[<parameter_list>, object]` is usually a better annotation in this kind of situation.
diff --git a/pyi.py b/pyi.py
index a04f5a32..5cec1bbf 100644
--- a/pyi.py
+++ b/pyi.py
@@ -1372,8 +1372,9 @@ def _Y090_error(self, node: ast.Subscript) -> None:
 
     def visit_Subscript(self, node: ast.Subscript) -> None:
         subscripted_object = node.value
+        interesting_modules = _TYPING_MODULES | {"builtins", "collections.abc"}
         subscripted_object_name = _get_name_of_class_if_from_modules(
-            subscripted_object, modules=_TYPING_MODULES | {"builtins"}
+            subscripted_object, modules=interesting_modules
         )
         self.visit(subscripted_object)
         if subscripted_object_name == "Literal":
@@ -1401,6 +1402,14 @@ def _visit_slice_tuple(self, node: ast.Tuple, parent: str | None) -> None:
                         self.visit(elt)
             else:
                 self.visit(node)
+        elif parent == "Callable":
+            self.visit(node)
+            if self.visiting_arg.active and len(node.elts) == 2:
+                return_annotation = node.elts[1]
+                if _is_None(return_annotation):
+                    self.error(node, Y091.format(bad_return="None"))
+                elif _is_Any(return_annotation):
+                    self.error(node, Y091.format(bad_return="Any"))
         else:
             self.visit(node)
 
@@ -2130,5 +2139,9 @@ def parse_options(options: argparse.Namespace) -> None:
     '"a tuple of length 1, in which the sole element is of type {typ!r}". '
     'Perhaps you meant "{new}"?'
 )
+Y091 = (
+    'Y091 "Callable" in argument annotations '
+    'should generally have "object" as the return type, not "{bad_return}"'
+)
 
-DISABLED_BY_DEFAULT = ["Y090"]
+DISABLED_BY_DEFAULT = ["Y090", "Y091"]
diff --git a/tests/bad_callbacks.pyi b/tests/bad_callbacks.pyi
new file mode 100644
index 00000000..0661d5d2
--- /dev/null
+++ b/tests/bad_callbacks.pyi
@@ -0,0 +1,29 @@
+# flags: --extend-select=Y091
+
+import collections.abc
+import typing
+from collections.abc import Callable
+from typing import Any
+
+from typing_extensions import TypeAlias
+
+def bad(
+    a: Callable[[], None],  # Y091 "Callable" in argument annotations should generally have "object" as the return type, not "None"
+    b: Callable[..., Any],  # Y091 "Callable" in argument annotations should generally have "object" as the return type, not "Any"
+    c: typing.Callable[[str, int], typing.Any],  # Y022 Use "collections.abc.Callable" instead of "typing.Callable" (PEP 585 syntax) # Y091 "Callable" in argument annotations should generally have "object" as the return type, not "Any"
+    d: collections.abc.Callable[[None], None],  # Y091 "Callable" in argument annotations should generally have "object" as the return type, not "None"
+    e: int | str | tuple[Callable[[], None], int, str],  # Y091 "Callable" in argument annotations should generally have "object" as the return type, not "None"
+) -> None: ...
+
+def good(
+    a: Callable[[], object],
+    b: Callable[..., object],
+    c: typing.Callable,  # Y022 Use "collections.abc.Callable" instead of "typing.Callable" (PEP 585 syntax)
+    d: collections.abc.Callable[[None], object],
+) -> None: ...
+
+def also_good() -> Callable[[], None]: ...
+
+_TypeAlias: TypeAlias = collections.abc.Callable[[int, str], Any]
+x: _TypeAlias
+y: typing.Callable[[], None]  # Y022 Use "collections.abc.Callable" instead of "typing.Callable" (PEP 585 syntax)