diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Revision history for streamly-fsnotify
 
+## 2.1 -- 2023-12-29
+
+- Remove file predicates as they're actually pointless. They do perhaps make sense in the context of `fsnotify` itself due to its approach to concurrency and action handling. But for this library, ignoring events via a predicate isn't really any different to just choosing not to do anything when it comes to matching on the received events. I had implicitly assumed when taking over this library that the predicates were smarter than that, telling upstream systems like `inotify` to totally ignore certain events. But that wouldn't have been possible with the old API, and would need support from `fsnotify` anyway, which may not be possible due to platform inconsistencies.
+
 ## 2.0 -- 2023-12-29
 
 With Streamly also making major breaking changes, this seemed like the time for a radical overhaul (we needed to move to the new stream type _at some point_, and that would break everything anyway). Essentially, having taken over this package nearly four years ago, and used it extensively, I've decided that it was unnecessarily complex. The line count is now _much_ shorter, but the interesting stuff is still here. In particular:
diff --git a/src/Streamly/FSNotify.hs b/src/Streamly/FSNotify.hs
--- a/src/Streamly/FSNotify.hs
+++ b/src/Streamly/FSNotify.hs
@@ -5,31 +5,26 @@
 C source files (which we take to be anything with a @.c@ extension). This program then writes that the event occurred,
 to what file, and when, forever.
 
-> {-# LANGUAGE GHC2021, BlockArguments, LambdaCase #-}
+> {\-# LANGUAGE GHC2021, BlockArguments, LambdaCase #-\}
 >
-> import Data.Functor.Contravariant (Predicate (Predicate))
 > import Streamly.Data.Fold qualified as SF
 > import Streamly.Data.Stream.Prelude qualified as SP
 > import System.FilePath (isExtensionOf, (</>))
 >
 > import Streamly.FSNotify
 >
-> isCSourceFile :: Predicate Event
-> isCSourceFile = Predicate \e ->
+> isCSourceFile :: Event -> Bool
+> isCSourceFile e =
 >     "c" `isExtensionOf` eventPath e && eventIsDirectory e == IsFile
 >
-> notDeletion :: Predicate Event
-> notDeletion = Predicate \case
->     Removed{} -> False
->     _ -> True
->
 > srcPath :: FilePath
 > srcPath = "/" </> "home" </> "gthomas" </> "c-project"
 >
 > main :: IO ()
-> main = SP.fold (SF.drainMapM go) $ watchTree srcPath $ isCSourceFile <> notDeletion
+> main = SP.fold (SF.drainMapM go) $ watchTree srcPath
 >   where
 >     go = \case
+>         e | not (isCSourceFile e) -> pure ()
 >         Added p t _ -> putStrLn $ "Created: " ++ show p ++ " at " ++ show t
 >         Modified p t _ -> putStrLn $ "Modified: " ++ show p ++ " at " ++ show t
 >         _ -> pure ()
@@ -44,7 +39,6 @@
 import Control.Concurrent.Chan (newChan, readChan)
 import Control.Monad.Catch (MonadCatch)
 import Control.Monad.IO.Class (liftIO)
-import Data.Functor.Contravariant (Predicate (getPredicate))
 import Streamly.Data.Stream.Prelude (MonadAsync, Stream)
 import Streamly.Data.Stream.Prelude qualified as S
 import Streamly.Data.StreamK qualified as SK
@@ -64,24 +58,23 @@
  )
 
 -- | Watch a given directory, but only at one level (thus, subdirectories will __not__ be watched recursively).
-watchDir :: (MonadAsync m, MonadCatch m) => FilePath -> Predicate Event -> Stream m Event
+watchDir :: (MonadAsync m, MonadCatch m) => FilePath -> Stream m Event
 watchDir = watch watchDirChan
 
 -- | Watch a given directory recursively (thus, subdirectories will also have their contents watched).
-watchTree :: (MonadAsync m, MonadCatch m) => FilePath -> Predicate Event -> Stream m Event
+watchTree :: (MonadAsync m, MonadCatch m) => FilePath -> Stream m Event
 watchTree = watch watchTreeChan
 
 watch ::
     (MonadAsync m, MonadCatch m) =>
     (WatchManager -> FilePath -> ActionPredicate -> EventChannel -> IO StopListening) ->
     FilePath ->
-    Predicate Event ->
     Stream m Event
-watch f p predicate = withInit
+watch f p = withInit
     do
         manager <- liftIO $ startManagerConf defaultConfig
         chan <- liftIO newChan
-        stop <- liftIO $ f manager p (getPredicate predicate) chan
+        stop <- liftIO $ f manager p (const True) chan
         pure (chan, liftIO $ stop >> liftIO (stopManager manager))
     \(chan, stop) -> S.finally stop $ S.repeatM $ liftIO $ readChan chan
   where
diff --git a/streamly-fsnotify.cabal b/streamly-fsnotify.cabal
--- a/streamly-fsnotify.cabal
+++ b/streamly-fsnotify.cabal
@@ -1,6 +1,6 @@
 cabal-version:       3.0
 name:                streamly-fsnotify
-version:             2.0
+version:             2.1
 synopsis:            Folder watching as a Streamly stream.
 description:
     Provides Streamly streams for both single-level and recursive folder watching.