diff --git a/src/Language/Haskell/Brittany/Internal.hs b/src/Language/Haskell/Brittany/Internal.hs
index c084c83..e1a111e 100644
--- a/src/Language/Haskell/Brittany/Internal.hs
+++ b/src/Language/Haskell/Brittany/Internal.hs
@@ -79,7 +79,7 @@ data InlineConfigTarget
 extractCommentConfigs
   :: ExactPrint.Anns
   -> TopLevelDeclNameMap
-  -> Either (String, String) (CConfig Option, PerItemConfig)
+  -> Either (String, String) (CConfig Maybe, PerItemConfig)
 extractCommentConfigs anns (TopLevelDeclNameMap declNameMap) = do
   let
     commentLiness =
diff --git a/src/Language/Haskell/Brittany/Internal/Config.hs b/src/Language/Haskell/Brittany/Internal/Config.hs
index 520be3f..b6ead91 100644
--- a/src/Language/Haskell/Brittany/Internal/Config.hs
+++ b/src/Language/Haskell/Brittany/Internal/Config.hs
@@ -118,7 +118,7 @@ forwardOptionsSyntaxExtsEnabled = ForwardOptions
   }
 
 -- brittany-next-binding { lconfig_indentPolicy: IndentPolicyLeft, lconfig_cols: 200 }
-cmdlineConfigParser :: CmdParser Identity out (CConfig Option)
+cmdlineConfigParser :: CmdParser Identity out (CConfig Maybe)
 cmdlineConfigParser = do
   -- TODO: why does the default not trigger; ind never should be []!!
   ind                <- addFlagReadParams "" ["indent"] "AMOUNT" (flagHelpStr "spaces per indentation level")
@@ -196,10 +196,10 @@ cmdlineConfigParser = do
     , _conf_obfuscate                 = wrapLast $ falseToNothing obfuscate
     }
  where
-  falseToNothing = Option . Bool.bool Nothing (Just True)
-  wrapLast :: Option a -> Option (Semigroup.Last a)
+  falseToNothing = Bool.bool Nothing (Just True)
+  wrapLast :: Maybe a -> Maybe (Semigroup.Last a)
   wrapLast = fmap Semigroup.Last
-  optionConcat :: (Semigroup.Semigroup (f a), Applicative f) => [a] -> Option (f a)
+  optionConcat :: (Semigroup.Semigroup (f a), Applicative f) => [a] -> Maybe (f a)
   optionConcat = mconcat . fmap (pure . pure)
 
 -- configParser :: Parser Config
@@ -230,7 +230,7 @@ cmdlineConfigParser = do
 -- If the second parameter is True and the file does not exist, writes the
 -- staticDefaultConfig to the file.
 readConfig
-  :: MonadIO m => System.IO.FilePath -> MaybeT m (Maybe (CConfig Option))
+  :: MonadIO m => System.IO.FilePath -> MaybeT m (Maybe (CConfig Maybe))
 readConfig path = do
   -- TODO: probably should catch IOErrors and then omit the existence check.
   exists <- liftIO $ System.Directory.doesFileExist path
@@ -278,7 +278,7 @@ findLocalConfigPath dir = do
 
 -- | Reads specified configs.
 readConfigs
-  :: CConfig Option        -- ^ Explicit options, take highest priority
+  :: CConfig Maybe        -- ^ Explicit options, take highest priority
   -> [System.IO.FilePath]  -- ^ List of config files to load and merge, highest priority first
   -> MaybeT IO Config
 readConfigs cmdlineConfig configPaths = do
@@ -290,7 +290,7 @@ readConfigs cmdlineConfig configPaths = do
 -- | Reads provided configs
 -- but also applies the user default configuration (with lowest priority)
 readConfigsWithUserConfig
-  :: CConfig Option        -- ^ Explicit options, take highest priority
+  :: CConfig Maybe        -- ^ Explicit options, take highest priority
   -> [System.IO.FilePath]  -- ^ List of config files to load and merge, highest priority first
   -> MaybeT IO Config
 readConfigsWithUserConfig cmdlineConfig configPaths = do
@@ -300,10 +300,9 @@ readConfigsWithUserConfig cmdlineConfig configPaths = do
 writeDefaultConfig :: MonadIO m => System.IO.FilePath -> m ()
 writeDefaultConfig path =
   liftIO $ ByteString.writeFile path $ Data.Yaml.encode $ cMap
-    (Option . Just . runIdentity)
+    (Just . runIdentity)
     staticDefaultConfig
 
 showConfigYaml :: Config -> String
 showConfigYaml = Data.ByteString.Char8.unpack . Data.Yaml.encode . cMap
   (\(Identity x) -> Just x)
-
diff --git a/src/Language/Haskell/Brittany/Internal/Config/Types.hs b/src/Language/Haskell/Brittany/Internal/Config/Types.hs
index 46b2ba1..18fb92b 100644
--- a/src/Language/Haskell/Brittany/Internal/Config/Types.hs
+++ b/src/Language/Haskell/Brittany/Internal/Config/Types.hs
@@ -23,7 +23,7 @@ import Data.Data ( Data )
 import Data.Coerce ( Coercible, coerce )
 
 import Data.Semigroup.Generic
-import Data.Semigroup ( Last, Option )
+import Data.Semigroup ( Last )
 
 import Data.CZipWith
 
@@ -215,12 +215,12 @@ deriving instance Show (CForwardOptions Identity)
 deriving instance Show (CPreProcessorConfig Identity)
 deriving instance Show (CConfig Identity)
 
-deriving instance Show (CDebugConfig Option)
-deriving instance Show (CLayoutConfig Option)
-deriving instance Show (CErrorHandlingConfig Option)
-deriving instance Show (CForwardOptions Option)
-deriving instance Show (CPreProcessorConfig Option)
-deriving instance Show (CConfig Option)
+deriving instance Show (CDebugConfig Maybe)
+deriving instance Show (CLayoutConfig Maybe)
+deriving instance Show (CErrorHandlingConfig Maybe)
+deriving instance Show (CForwardOptions Maybe)
+deriving instance Show (CPreProcessorConfig Maybe)
+deriving instance Show (CConfig Maybe)
 
 deriving instance Data (CDebugConfig Identity)
 deriving instance Data (CLayoutConfig Identity)
@@ -229,24 +229,24 @@ deriving instance Data (CForwardOptions Identity)
 deriving instance Data (CPreProcessorConfig Identity)
 deriving instance Data (CConfig Identity)
 
-deriving instance Data (CDebugConfig Option)
-deriving instance Data (CLayoutConfig Option)
-deriving instance Data (CErrorHandlingConfig Option)
-deriving instance Data (CForwardOptions Option)
-deriving instance Data (CPreProcessorConfig Option)
-deriving instance Data (CConfig Option)
+deriving instance Data (CDebugConfig Maybe)
+deriving instance Data (CLayoutConfig Maybe)
+deriving instance Data (CErrorHandlingConfig Maybe)
+deriving instance Data (CForwardOptions Maybe)
+deriving instance Data (CPreProcessorConfig Maybe)
+deriving instance Data (CConfig Maybe)
 
-instance Semigroup.Semigroup (CDebugConfig Option) where
+instance Semigroup.Semigroup (CDebugConfig Maybe) where
   (<>) = gmappend
-instance Semigroup.Semigroup (CLayoutConfig Option) where
+instance Semigroup.Semigroup (CLayoutConfig Maybe) where
   (<>) = gmappend
-instance Semigroup.Semigroup (CErrorHandlingConfig Option) where
+instance Semigroup.Semigroup (CErrorHandlingConfig Maybe) where
   (<>) = gmappend
-instance Semigroup.Semigroup (CForwardOptions Option) where
+instance Semigroup.Semigroup (CForwardOptions Maybe) where
   (<>) = gmappend
-instance Semigroup.Semigroup (CPreProcessorConfig Option) where
+instance Semigroup.Semigroup (CPreProcessorConfig Maybe) where
   (<>) = gmappend
-instance Semigroup.Semigroup (CConfig Option) where
+instance Semigroup.Semigroup (CConfig Maybe) where
   (<>) = gmappend
 
 instance Semigroup.Semigroup (CDebugConfig Identity) where
@@ -262,22 +262,22 @@ instance Semigroup.Semigroup (CPreProcessorConfig Identity) where
 instance Semigroup.Semigroup (CConfig Identity) where
   (<>) = gmappend
 
-instance Monoid (CDebugConfig Option) where
+instance Monoid (CDebugConfig Maybe) where
   mempty = gmempty
   mappend = gmappend
-instance Monoid (CLayoutConfig Option) where
+instance Monoid (CLayoutConfig Maybe) where
   mempty = gmempty
   mappend = gmappend
-instance Monoid (CErrorHandlingConfig Option) where
+instance Monoid (CErrorHandlingConfig Maybe) where
   mempty = gmempty
   mappend = gmappend
-instance Monoid (CForwardOptions Option) where
+instance Monoid (CForwardOptions Maybe) where
   mempty = gmempty
   mappend = gmappend
-instance Monoid (CPreProcessorConfig Option) where
+instance Monoid (CPreProcessorConfig Maybe) where
   mempty = gmempty
   mappend = gmappend
-instance Monoid (CConfig Option) where
+instance Monoid (CConfig Maybe) where
   mempty = gmempty
   mappend = gmappend
 
diff --git a/src/Language/Haskell/Brittany/Internal/Config/Types/Instances.hs b/src/Language/Haskell/Brittany/Internal/Config/Types/Instances.hs
index 7bf38f4..1ea7bab 100644
--- a/src/Language/Haskell/Brittany/Internal/Config/Types/Instances.hs
+++ b/src/Language/Haskell/Brittany/Internal/Config/Types/Instances.hs
@@ -51,27 +51,15 @@ aesonDecodeOptionsBrittany = Aeson.defaultOptions
   instance FromJSON (type Maybe) where\
     parseJSON = Aeson.genericParseJSON aesonDecodeOptionsBrittany;\
     {-# NOINLINE parseJSON #-}
-#define makeFromJSONOption(type)\
-  instance FromJSON (type Option) where\
-    parseJSON = fmap (cMap Option) . parseJSON;\
-    {-# NOINLINE parseJSON #-}
 #define makeToJSONMaybe(type)\
   instance ToJSON (type Maybe) where\
     toJSON     = Aeson.genericToJSON aesonDecodeOptionsBrittany;\
     {-# NOINLINE toJSON #-};\
     toEncoding = Aeson.genericToEncoding aesonDecodeOptionsBrittany;\
     {-# NOINLINE toEncoding #-}
-#define makeToJSONOption(type)\
-  instance ToJSON (type Option) where\
-    toJSON     = toJSON     . cMap getOption;\
-    {-# NOINLINE toJSON #-};\
-    toEncoding = toEncoding . cMap getOption;\
-    {-# NOINLINE toEncoding #-}
 
 
-makeFromJSONOption(CDebugConfig)
 makeFromJSONMaybe(CDebugConfig)
-makeToJSONOption(CDebugConfig)
 makeToJSONMaybe(CDebugConfig)
 
 makeFromJSON(IndentPolicy)
@@ -85,28 +73,18 @@ makeToJSON(CPPMode)
 makeFromJSON(ExactPrintFallbackMode)
 makeToJSON(ExactPrintFallbackMode)
 
-makeFromJSONOption(CLayoutConfig)
 makeFromJSONMaybe(CLayoutConfig)
-makeToJSONOption(CLayoutConfig)
 makeToJSONMaybe(CLayoutConfig)
 
-makeFromJSONOption(CErrorHandlingConfig)
 makeFromJSONMaybe(CErrorHandlingConfig)
-makeToJSONOption(CErrorHandlingConfig)
 makeToJSONMaybe(CErrorHandlingConfig)
 
-makeFromJSONOption(CForwardOptions)
 makeFromJSONMaybe(CForwardOptions)
-makeToJSONOption(CForwardOptions)
 makeToJSONMaybe(CForwardOptions)
 
-makeFromJSONOption(CPreProcessorConfig)
 makeFromJSONMaybe(CPreProcessorConfig)
-makeToJSONOption(CPreProcessorConfig)
 makeToJSONMaybe(CPreProcessorConfig)
 
-makeFromJSONOption(CConfig)
-makeToJSONOption(CConfig)
 makeToJSONMaybe(CConfig)
 
 -- This custom instance ensures the "omitNothingFields" behaviour not only for
diff --git a/src/Language/Haskell/Brittany/Internal/Prelude.hs b/src/Language/Haskell/Brittany/Internal/Prelude.hs
index ef8cb90..6c52450 100644
--- a/src/Language/Haskell/Brittany/Internal/Prelude.hs
+++ b/src/Language/Haskell/Brittany/Internal/Prelude.hs
@@ -32,7 +32,6 @@ import Data.Char                     as E ( Char )
 import Data.Either                   as E ( Either(..) )
 import Data.IORef                    as E ( IORef )
 import Data.Maybe                    as E ( Maybe(..) )
-import Data.Semigroup                as E ( Option(..) )
 import Data.Monoid                   as E ( Endo(..)
                                           , All(..)
                                           , Any(..)
diff --git a/src/Language/Haskell/Brittany/Internal/Types.hs b/src/Language/Haskell/Brittany/Internal/Types.hs
index f402e56..4979a4e 100644
--- a/src/Language/Haskell/Brittany/Internal/Types.hs
+++ b/src/Language/Haskell/Brittany/Internal/Types.hs
@@ -29,8 +29,8 @@ import           Data.Generics.Uniplate.Direct as Uniplate
 
 
 data PerItemConfig = PerItemConfig
-  { _icd_perBinding :: Map String (CConfig Option)
-  , _icd_perKey :: Map ExactPrint.Types.AnnKey (CConfig Option)
+  { _icd_perBinding :: Map String (CConfig Maybe)
+  , _icd_perKey :: Map ExactPrint.Types.AnnKey (CConfig Maybe)
   }
   deriving Data.Data.Data
 
diff --git a/src/Language/Haskell/Brittany/Internal/Utils.hs b/src/Language/Haskell/Brittany/Internal/Utils.hs
index 0654c12..ea2b4ac 100644
--- a/src/Language/Haskell/Brittany/Internal/Utils.hs
+++ b/src/Language/Haskell/Brittany/Internal/Utils.hs
@@ -79,9 +79,9 @@ showOutputable = GHC.showPpr GHC.unsafeGlobalDynFlags
 fromMaybeIdentity :: Identity a -> Maybe a -> Identity a
 fromMaybeIdentity x y = Data.Coerce.coerce $ fromMaybe (Data.Coerce.coerce x) y
 
-fromOptionIdentity :: Identity a -> Option a -> Identity a
+fromOptionIdentity :: Identity a -> Maybe a -> Identity a
 fromOptionIdentity x y =
-  Data.Coerce.coerce $ fromMaybe (Data.Coerce.coerce x) $ getOption y
+  Data.Coerce.coerce $ fromMaybe (Data.Coerce.coerce x) y
 
 -- maximum monoid over N+0
 -- or more than N, because Num is allowed.