diff --git a/app/Main.hs b/app/Main.hs
index 1e999c1..2c66e55 100644
--- a/app/Main.hs
+++ b/app/Main.hs
@@ -1,7 +1,6 @@
 module Main where
 
 import Control.Monad (unless, when)
-import Data.List (isPrefixOf)
 import Data.Maybe (isJust)
 import qualified Data.Text as T
 import qualified Data.Text.IO as TIO
@@ -25,20 +24,8 @@ import ScriptHs.Version (
     tagStyleFor,
     tagVersion,
  )
-
--- | Parsed command-line options.
-data Args = Args
-    { argScript :: Maybe FilePath
-    , argOutput :: Maybe FilePath
-    , argPackages :: [FilePath]
-    , argNoLocalProject :: Bool
-    , argInPlace :: Bool
-    , argHelp :: Bool
-    , argVersion :: Bool
-    }
-
-emptyArgs :: Args
-emptyArgs = Args Nothing Nothing [] False False False False
+import ScriptHs.CLI.Types
+import ScriptHs.Markdown
 
 main :: IO ()
 main = do
@@ -61,7 +48,7 @@ main = do
                                 { roPackages = pkgs
                                 , roEnclosingProject = not (argNoLocalProject a)
                                 }
-                    dispatch opts path outPath
+                    dispatch (argOutputStyle a) (argCodeStyle a) opts path outPath
 
 {- | Resolve the output destination, honouring @--in-place@: write back over the
 notebook itself. In-place is only meaningful for notebooks (the @.ghci@\/@.hs@
@@ -80,43 +67,16 @@ resolveOutput a path
 isNotebook :: FilePath -> Bool
 isNotebook path = takeExtension path `elem` [".md", ".markdown"]
 
-dispatch :: RunOptions -> FilePath -> Maybe FilePath -> IO ()
-dispatch opts path outputPath =
+dispatch :: OutputStyle ->  CodeStyle -> RunOptions -> FilePath -> Maybe FilePath -> IO ()
+dispatch outputStyle codeStyle opts path outputPath =
     case takeExtension path of
-        ".md" -> runNotebook opts path outputPath
-        ".markdown" -> runNotebook opts path outputPath
+        ".md" -> runNotebook outputStyle codeStyle opts path outputPath
+        ".markdown" -> runNotebook outputStyle codeStyle opts path outputPath
         _ -> do
             contents <- TIO.readFile path
             let sf = parseScript contents
             runScript opts path sf
 
-{- | Parse args: @[-o FILE | --output=FILE] [-i | --in-place] [--package DIR |
--p DIR | --package=DIR]... [--no-local-project] [-h | --help] <script>@. The
-script is the sole non-flag argument.
--}
-parseArgs :: [String] -> Either String Args
-parseArgs = go emptyArgs
-  where
-    go a [] = Right a
-    go a ("-o" : f : rest) = go a{argOutput = Just f} rest
-    go _ ["-o"] = Left "-o requires a filename"
-    go a (tok : rest)
-        | tok == "-p" || tok == "--package" = case rest of
-            (d : rest') -> go a{argPackages = argPackages a ++ [d]} rest'
-            [] -> Left (tok ++ " requires a directory")
-        | Just f <- stripFlag "--output=" tok = go a{argOutput = Just f} rest
-        | Just d <- stripFlag "--package=" tok =
-            go a{argPackages = argPackages a ++ [d]} rest
-        | tok == "--no-local-project" = go a{argNoLocalProject = True} rest
-        | tok == "-i" || tok == "--in-place" = go a{argInPlace = True} rest
-        | tok == "-h" || tok == "--help" = go a{argHelp = True} rest
-        | tok == "-v" || tok == "--version" = go a{argVersion = True} rest
-        | "-" `isPrefixOf` tok = Left ("unknown flag: " ++ tok)
-        | otherwise = case argScript a of
-            Nothing -> go a{argScript = Just tok} rest
-            Just _ -> Left ("unexpected extra argument: " ++ tok)
-    stripFlag p s = if p `isPrefixOf` s then Just (drop (length p) s) else Nothing
-
 -- | Resolve a @--package@ dir to absolute, requiring a package root (a @.cabal@).
 resolvePackageDir :: FilePath -> IO FilePath
 resolvePackageDir dir = do
@@ -171,6 +131,8 @@ helpText prog =
         , "  --no-local-project        do not auto-include the enclosing cabal project"
         , "  -h, --help                show this help"
         , "  -v, --version             show the scripths version"
+        , "  --code-style=display|remove    control how code fences should appear after processing (default: display)"
+        , "  --output-style=quoted|raw      control how evaluted code is outputed (default: quoted)"
         , ""
         , "Files may carry a first-line version tag recording the scripths that wrote"
         , "them ('-- scripths: X' in scripts, '<!-- scripths: X -->' in notebooks); a"
diff --git a/scripths.cabal b/scripths.cabal
index 56ac4cc..54fc544 100644
--- a/scripths.cabal
+++ b/scripths.cabal
@@ -23,11 +23,12 @@ common warnings
 
 library
     import:           warnings
-    exposed-modules:  ScriptHs.Parser,
+    exposed-modules:  ScriptHs.CLI.Types,
                       ScriptHs.Compiled,
-                      ScriptHs.Render,
                       ScriptHs.Markdown,
                       ScriptHs.Notebook,
+                      ScriptHs.Parser,
+                      ScriptHs.Render,
                       ScriptHs.Repl,
                       ScriptHs.Run,
                       ScriptHs.Version
diff --git a/src/ScriptHs/CLI/Types.hs b/src/ScriptHs/CLI/Types.hs
new file mode 100644
index 0000000..4df1378
--- /dev/null
+++ b/src/ScriptHs/CLI/Types.hs
@@ -0,0 +1,72 @@
+module ScriptHs.CLI.Types (
+    Args (..),
+    emptyArgs,
+    parseArgs,
+) where
+
+import Data.List (isPrefixOf)
+import ScriptHs.Markdown
+
+-- | Parsed command-line options.
+data Args = Args
+    { argScript :: Maybe FilePath
+    , argOutput :: Maybe FilePath
+    , argPackages :: [FilePath]
+    , argNoLocalProject :: Bool
+    , argInPlace :: Bool
+    , argHelp :: Bool
+    , argVersion :: Bool
+    , argCodeStyle :: CodeStyle
+    , argOutputStyle :: OutputStyle
+    }
+
+emptyArgs :: Args
+emptyArgs =
+    Args
+        { argScript = Nothing
+        , argOutput = Nothing
+        , argPackages = []
+        , argNoLocalProject = False
+        , argInPlace = False
+        , argHelp = False
+        , argVersion = False
+        , argCodeStyle = DisplayCode
+        , argOutputStyle = OutputQuoted
+        }
+
+{- | Parse args: @[-o FILE | --output=FILE] [-i | --in-place] [--package DIR |
+-p DIR | --package=DIR]... [--no-local-project] [-h | --help] <script>@. The
+script is the sole non-flag argument.
+-}
+parseArgs :: [String] -> Either String Args
+parseArgs = go emptyArgs
+  where
+    go a [] = Right a
+    go a ("-o" : f : rest) = go a{argOutput = Just f} rest
+    go _ ["-o"] = Left "-o requires a filename"
+    go a (tok : rest)
+        | tok == "-p" || tok == "--package" = case rest of
+            (d : rest') -> go a{argPackages = argPackages a ++ [d]} rest'
+            [] -> Left (tok ++ " requires a directory")
+        | Just f <- stripFlag "--output=" tok = go a{argOutput = Just f} rest
+        | Just d <- stripFlag "--package=" tok =
+            go a{argPackages = argPackages a ++ [d]} rest
+        | tok == "--no-local-project" = go a{argNoLocalProject = True} rest
+        | tok == "-i" || tok == "--in-place" = go a{argInPlace = True} rest
+        | tok == "-h" || tok == "--help" = go a{argHelp = True} rest
+        | tok == "-v" || tok == "--version" = go a{argVersion = True} rest
+        | tok == "--code-style" = case rest of
+            (d : rest') -> case parseCodeStyle d of
+                Just codeStyle -> go a{argCodeStyle = codeStyle} rest'
+                Nothing -> Left ("Could not parse code style: " ++ tok)
+            [] -> Left (tok ++ " requires a code style")
+        | tok == "--output-style" = case rest of
+            (d : rest') -> case parseOutputStyle d of
+                Just codeStyle -> go a{argOutputStyle = codeStyle} rest'
+                Nothing -> Left ("Could not parse output style: " ++ tok)
+            [] -> Left (tok ++ " requires a output style")
+        | "-" `isPrefixOf` tok = Left ("unknown flag: " ++ tok)
+        | otherwise = case argScript a of
+            Nothing -> go a{argScript = Just tok} rest
+            Just _ -> Left ("unexpected extra argument: " ++ tok)
+    stripFlag p s = if p `isPrefixOf` s then Just (drop (length p) s) else Nothing
diff --git a/src/ScriptHs/Markdown.hs b/src/ScriptHs/Markdown.hs
index bee4004..4ec9abd 100644
--- a/src/ScriptHs/Markdown.hs
+++ b/src/ScriptHs/Markdown.hs
@@ -4,11 +4,46 @@ module ScriptHs.Markdown (
     reassemble,
     MimeType (..),
     CodeOutput (..),
+    CodeStyle (..),
+    parseCodeStyle,
+    defaultCodeStyle,
+    OutputStyle (..),
+    parseOutputStyle,
+    defaultOutputStyle,
 ) where
 
 import Data.Text (Text)
 import qualified Data.Text as T
 
+{- |  Directs how the original code fences are styled
+  in the processed output.
+-}
+data CodeStyle
+    = DisplayCode
+    | RemoveCode
+    deriving (Eq, Ord, Show)
+
+parseCodeStyle :: String -> Maybe CodeStyle
+parseCodeStyle "display" = Just DisplayCode
+parseCodeStyle "remove" = Just RemoveCode
+parseCodeStyle _ = Nothing
+
+defaultCodeStyle :: CodeStyle
+defaultCodeStyle = DisplayCode
+
+data OutputStyle
+    = OutputQuoted
+    | OutputRaw
+    deriving (Eq, Ord, Show)
+
+parseOutputStyle :: String -> Maybe OutputStyle
+parseOutputStyle "quoted" = Just OutputQuoted
+parseOutputStyle "raw" = Just OutputRaw
+parseOutputStyle _ = Nothing
+
+defaultOutputStyle :: OutputStyle
+defaultOutputStyle = OutputQuoted
+
 data MimeType
     = MimeHtml
     | MimeMarkdown
@@ -19,7 +54,8 @@ data MimeType
     | MimePlain
     deriving (Show, Eq)
 
-data CodeOutput = CodeOutput MimeType Text deriving (Show, Eq)
+data CodeOutput = CodeOutput OutputStyle MimeType Text
+    deriving (Show, Eq)
 
 data Segment
     = Prose Text
@@ -48,7 +84,8 @@ parseMarkdown' acc (line : rest) = case fenceLang line of
                                 (cOutput, afterOutput) = span (T.isPrefixOf "> ") xs
                                 mType = mimeFromTag x
                              in
-                                ( Just (CodeOutput mType (T.unlines (map (T.drop (T.length "> ")) cOutput)))
+                                ( Just
+                                    (CodeOutput OutputQuoted mType (T.unlines (map (T.drop (T.length "> ")) cOutput)))
                                 , afterOutput
                                 )
                 [] -> (Nothing, rest')
@@ -91,8 +128,8 @@ fenceCodeSegment lang output
 seam between segments collapses to one blank line and the document's leading/
 trailing blanks are trimmed, so re-running (e.g. @--in-place@) adds no new lines.
 -}
-reassemble :: [Segment] -> Text
-reassemble = finalize . foldr (joinSeam . renderSegment) ""
+reassemble :: CodeStyle -> [Segment] -> Text
+reassemble codeStyle = finalize . foldr (joinSeam . renderSegment codeStyle) ""
   where
     joinSeam "" acc = acc
     joinSeam piece "" = piece
@@ -106,19 +143,26 @@ reassemble = finalize . foldr (joinSeam . renderSegment) ""
         let stripped = T.dropWhileEnd (== '\n') (T.dropWhile (== '\n') t)
          in if T.null stripped then "" else stripped <> "\n"
 
-renderSegment :: Segment -> Text
-renderSegment (Prose t) = t
-renderSegment (CodeBlock lang code Nothing) = fenceCodeSegment lang code
-renderSegment (CodeBlock lang code (Just output)) = fenceCodeSegment lang code <> blockQuote output
+renderSegment :: CodeStyle -> Segment -> Text
+renderSegment _ (Prose t) = t
+renderSegment _ (CodeBlock lang code Nothing) = fenceCodeSegment lang code
+renderSegment codeStyle (CodeBlock lang code (Just output)) =
+    let codeFence = case codeStyle of
+            DisplayCode -> fenceCodeSegment lang code
+            RemoveCode -> mempty
+     in codeFence <> blockQuote output
 
 blockQuote :: CodeOutput -> Text
-blockQuote (CodeOutput mimeType t) =
+blockQuote (CodeOutput outputStyle mimeType t) =
     let
         ls = (mimeMarker <> mimeIndicator mimeType <> " -->") : T.lines t
         trimmed = reverse $ dropWhile T.null $ reverse ls
-        quoted = T.unlines $ map (\l -> if T.null l then "> " else "> " <> l) trimmed
+        styling = case outputStyle of
+            OutputQuoted -> "> "
+            OutputRaw -> ""
+        output = T.unlines $ map (\l -> if T.null l then styling else styling <> l) trimmed
      in
-        quoted <> "\n"
+        output <> "\n"
 
 mimeIndicator :: MimeType -> Text
 mimeIndicator m = case m of
diff --git a/src/ScriptHs/Notebook.hs b/src/ScriptHs/Notebook.hs
index c5ad303..3f9389b 100644
--- a/src/ScriptHs/Notebook.hs
+++ b/src/ScriptHs/Notebook.hs
@@ -13,7 +13,9 @@ import System.CPUTime (getCPUTime)
 
 import ScriptHs.Markdown (
     CodeOutput (..),
+    CodeStyle,
     MimeType (..),
+    OutputStyle,
     Segment (..),
     parseMarkdown,
     reassemble,
@@ -37,10 +39,11 @@ type IndexedBlocks = [(Int, [Line])]
 clean; output written to a file (@-o@ or @--in-place@) is stamped with the
 current scripths version tag at the top.
 -}
-runNotebook :: RunOptions -> FilePath -> Maybe FilePath -> IO ()
-runNotebook opts path outputPath = do
+runNotebook ::
+    OutputStyle -> CodeStyle -> RunOptions -> FilePath -> Maybe FilePath -> IO ()
+runNotebook outputStyle codeStyle opts path outputPath = do
     contents <- stripBom <$> TIO.readFile path
-    outputMd <- processNotebook opts path contents
+    outputMd <- processNotebook outputStyle codeStyle opts path contents
     case outputPath of
         Nothing -> TIO.putStr outputMd
         Just output -> TIO.writeFile output (stampVersion NotebookTag outputMd)
@@ -49,22 +52,33 @@ runNotebook opts path outputPath = do
 stripBom :: Text -> Text
 stripBom t = fromMaybe t (T.stripPrefix "\65279" t)
 
-processNotebook :: RunOptions -> FilePath -> Text -> IO Text
-processNotebook opts notebookPath contents = do
+processNotebook ::
+    OutputStyle -> CodeStyle -> RunOptions -> FilePath -> Text -> IO Text
+processNotebook outputStyle codeStyle opts notebookPath contents = do
     let indexedSegments = zip [0 ..] (parseMarkdown contents)
         (metas, indexedCodeBlocks) = parseBlocks indexedSegments
     if null indexedCodeBlocks
         then pure contents
-        else executeCodeCells opts notebookPath metas indexedSegments indexedCodeBlocks
+        else
+            executeCodeCells
+                outputStyle
+                codeStyle
+                opts
+                notebookPath
+                metas
+                indexedSegments
+                indexedCodeBlocks
 
 executeCodeCells ::
+    OutputStyle ->
+    CodeStyle ->
     RunOptions ->
     FilePath ->
     CabalMeta ->
     IndexedSegments ->
     IndexedBlocks ->
     IO Text
-executeCodeCells opts notebookPath meta allSegments codeBlocks = do
+executeCodeCells outputStyle codeStyle opts notebookPath meta allSegments codeBlocks = do
     let ghciScript0 = generatedMarkedScript "" codeBlocks
     nonce <- makeNonce ghciScript0
     let ghciScript = generatedMarkedScript nonce codeBlocks
@@ -76,8 +90,8 @@ executeCodeCells opts notebookPath meta allSegments codeBlocks = do
             map
                 (fmap (scrubCellOutput nonce indices))
                 (splitByMarkers nonce rawOutput indices)
-        blocksWithOutput = addOutputToSegments outputs allSegments
-    pure $ reassemble blocksWithOutput
+        blocksWithOutput = addOutputToSegments outputStyle outputs allSegments
+    pure $ reassemble codeStyle blocksWithOutput
 
 {- | A per-run hex nonce woven into every cell-end marker so a cell's own output
 cannot spoof a marker and misattribute another cell's output. Mixes the process
@@ -104,11 +118,16 @@ scrubCellOutput nonce indices =
   where
     stripMarkers t = foldr (\i acc -> T.replace (mkMarker nonce i) "" acc) t indices
 
-addOutputToSegments :: [(Int, Text)] -> IndexedSegments -> [Segment]
-addOutputToSegments outputs = map addOutput
+addOutputToSegments ::
+    OutputStyle -> [(Int, Text)] -> IndexedSegments -> [Segment]
+addOutputToSegments outputStyle outputs = map addOutput
   where
     addOutput :: (Int, Segment) -> Segment
-    addOutput (i, CodeBlock lang code _) = CodeBlock lang code (fmap (CodeOutput MimePlain) (lookup i outputs))
+    addOutput (i, CodeBlock lang code _) =
+        CodeBlock
+            lang
+            code
+            (fmap (CodeOutput outputStyle MimePlain) (lookup i outputs))
     addOutput (_, seg) = seg
 
 mkIndexedCodeSegments :: IndexedSegments -> IndexedSegments
diff --git a/test/Test/Integration.hs b/test/Test/Integration.hs
index 142e3cb..d014533 100644
--- a/test/Test/Integration.hs
+++ b/test/Test/Integration.hs
@@ -5,6 +5,7 @@ import System.Environment (lookupEnv)
 import Test.Tasty (TestTree, testGroup)
 import Test.Tasty.HUnit (assertBool, testCase)
 
+import ScriptHs.Markdown
 import ScriptHs.Notebook (processNotebook)
 import ScriptHs.Run (defaultRunOptions)
 
@@ -34,7 +35,13 @@ integrationTests =
                                 , "\"rendered-ok\" :: String"
                                 , "```"
                                 ]
-                    out <- processNotebook defaultRunOptions "/tmp/scripths-integration.md" nb
+                    out <-
+                        processNotebook
+                            defaultOutputStyle
+                            defaultCodeStyle
+                            defaultRunOptions
+                            "/tmp/scripths-integration.md"
+                            nb
                     assertBool "renders the cell value" ("rendered-ok" `T.isInfixOf` out)
                     assertBool
                         "no ScripthsInternal leak"
diff --git a/test/Test/Markdown.hs b/test/Test/Markdown.hs
index 4089232..d8f2eaf 100644
--- a/test/Test/Markdown.hs
+++ b/test/Test/Markdown.hs
@@ -10,13 +10,7 @@ import Test.Tasty.HUnit (
 
 import Data.Text (Text)
 import qualified Data.Text as T
-import ScriptHs.Markdown (
-    CodeOutput (..),
-    MimeType (..),
-    Segment (CodeBlock, Prose),
-    parseMarkdown,
-    reassemble,
- )
+import ScriptHs.Markdown
 
 markdownTests :: TestTree
 markdownTests =
@@ -105,7 +99,7 @@ markdownTests =
                 let segs = parseMarkdown input
                 length segs @?= 2
                 case segs of
-                    [CodeBlock _ _ (Just (CodeOutput m _)), Prose _] -> assertBool "mime is latex" (m == MimeLatex)
+                    [CodeBlock _ _ (Just (CodeOutput _ m _)), Prose _] -> assertBool "mime is latex" (m == MimeLatex)
                     other -> assertFailure $ "expected [CodeBlock, Prose], got: " ++ show other
             , testCase "svg mimetype" $ do
                 let input =
@@ -122,7 +116,7 @@ markdownTests =
                 let segs = parseMarkdown input
                 length segs @?= 2
                 case segs of
-                    [CodeBlock _ _ (Just (CodeOutput m _)), Prose _] -> assertBool "mime is svg" (m == MimeSvg)
+                    [CodeBlock _ _ (Just (CodeOutput _ m _)), Prose _] -> assertBool "mime is svg" (m == MimeSvg)
                     other -> assertFailure $ "expected [CodeBlock, Prose], got: " ++ show other
             , testCase "multiple code blocks" $ do
                 let input =
@@ -152,7 +146,7 @@ markdownTests =
                 length outputBlocks @?= 2
                 assertBool
                     "all mimeType plain"
-                    (all (== MimePlain) [m | (Just (CodeOutput m _)) <- outputBlocks])
+                    (all (== MimePlain) [m | (Just (CodeOutput _ m _)) <- outputBlocks])
             , testCase "non-haskell code block preserved" $ do
                 let input =
                         T.unlines
@@ -197,32 +191,50 @@ markdownTests =
         , testGroup
             "reassemble"
             [ testCase "prose without output" $ do
-                let result = reassemble [Prose "Hello\n"]
+                let result = reassemble defaultCodeStyle [Prose "Hello\n"]
                 result @?= "Hello\n"
             , testCase "code block without output" $ do
-                let result = reassemble [CodeBlock "haskell" "print 42\n" Nothing]
+                let result = reassemble defaultCodeStyle [CodeBlock "haskell" "print 42\n" Nothing]
                 assertBool "has fence" (T.isInfixOf "```haskell" result)
                 assertBool "has code" (T.isInfixOf "print 42" result)
                 assertBool "no blockquote" (not $ T.isInfixOf "> " result)
             , testCase "code block with output" $ do
                 let result =
-                        reassemble [CodeBlock "haskell" "print 42\n" (Just $ CodeOutput MimePlain "42")]
+                        reassemble
+                            defaultCodeStyle
+                            [ CodeBlock
+                                "haskell"
+                                "print 42\n"
+                                (Just $ CodeOutput defaultOutputStyle MimePlain "42")
+                            ]
                 assertBool "has fence" (T.isInfixOf "```haskell" result)
                 assertBool "has code" (T.isInfixOf "print 42" result)
                 assertBool "has blockquote" (T.isInfixOf "> 42" result)
             , testCase "code block with multi-line output" $ do
                 let result =
-                        reassemble [CodeBlock "hs" "print [1,2]\n" (Just $ CodeOutput MimePlain "1\n2")]
+                        reassemble
+                            defaultCodeStyle
+                            [ CodeBlock
+                                "hs"
+                                "print [1,2]\n"
+                                (Just $ CodeOutput defaultOutputStyle MimePlain "1\n2")
+                            ]
                 assertBool "has > 1" (T.isInfixOf "> 1" result)
                 assertBool "has > 2" (T.isInfixOf "> 2" result)
             , testCase "full document roundtrip" $ do
                 let segs =
                         [ Prose "# Title\n\n"
-                        , CodeBlock "haskell" "print 42\n" (Just $ CodeOutput MimePlain "42")
+                        , CodeBlock
+                            "haskell"
+                            "print 42\n"
+                            (Just $ CodeOutput defaultOutputStyle MimePlain "42")
                         , Prose "\nSome text.\n"
-                        , CodeBlock "haskell" "print 99\n" (Just $ CodeOutput MimePlain "99")
+                        , CodeBlock
+                            "haskell"
+                            "print 99\n"
+                            (Just $ CodeOutput defaultOutputStyle MimePlain "99")
                         ]
-                let result = reassemble segs
+                let result = reassemble defaultCodeStyle segs
 
                 assertBool "has title" (T.isInfixOf "# Title" result)
                 assertBool "has first output" (T.isInfixOf "> 42" result)
@@ -238,17 +250,38 @@ markdownTests =
                 assertBool "middle before code2" (middleIdx < code2Idx)
             ]
         , testGroup
-            "blockquote"
-            [ testCase "single line" $ do
-                let result = reassemble [CodeBlock "hs" "x\n" (Just $ CodeOutput MimePlain "hello")]
-                assertBool "blockquoted" (T.isInfixOf "> hello" result)
-            , testCase "empty lines in output get bare >" $ do
-                let result = reassemble [CodeBlock "hs" "x\n" (Just $ CodeOutput MimePlain "a\n\nb")]
-                assertBool "has bare >" (T.isInfixOf "\n> \n" result)
-            , testCase "renders the scripths:mime marker (not the legacy sabela)" $ do
-                let result = reassemble [CodeBlock "hs" "x\n" (Just $ CodeOutput MimePlain "y")]
-                assertBool "uses scripths:mime" (T.isInfixOf "scripths:mime" result)
-                assertBool "no sabela:mime" (not (T.isInfixOf "sabela:mime" result))
+            "Output style"
+            [ testGroup
+                "raw"
+                [ testCase "Raw output" $ do
+                    let result =
+                            reassemble
+                                defaultCodeStyle
+                                [CodeBlock "hs" "x\n" (Just $ CodeOutput OutputRaw MimePlain "hello")]
+                    assertBool "Not quoted" (T.isInfixOf "hello" result)
+                ]
+            , testGroup
+                "blockquote"
+                [ testCase "single line" $ do
+                    let result =
+                            reassemble
+                                defaultCodeStyle
+                                [CodeBlock "hs" "x\n" (Just $ CodeOutput defaultOutputStyle MimePlain "hello")]
+                    assertBool "blockquoted" (T.isInfixOf "> hello" result)
+                , testCase "empty lines in output get bare >" $ do
+                    let result =
+                            reassemble
+                                defaultCodeStyle
+                                [CodeBlock "hs" "x\n" (Just $ CodeOutput defaultOutputStyle MimePlain "a\n\nb")]
+                    assertBool "has bare >" (T.isInfixOf "\n> \n" result)
+                , testCase "renders the scripths:mime marker (not the legacy sabela)" $ do
+                    let result =
+                            reassemble
+                                defaultCodeStyle
+                                [CodeBlock "hs" "x\n" (Just $ CodeOutput defaultOutputStyle MimePlain "y")]
+                    assertBool "uses scripths:mime" (T.isInfixOf "scripths:mime" result)
+                    assertBool "no sabela:mime" (not (T.isInfixOf "sabela:mime" result))
+                ]
             ]
         , testGroup
             "idempotency (no extra blank lines on re-run)"
@@ -297,7 +330,7 @@ markdownTests =
         ]
 
 roundTrip :: Text -> Text
-roundTrip = reassemble . parseMarkdown
+roundTrip = reassemble defaultCodeStyle . parseMarkdown
 
 nlCount :: Text -> Int
 nlCount = T.length . T.filter (== '\n')
diff --git a/test/Test/Notebook.hs b/test/Test/Notebook.hs
index f401a77..a327923 100644
--- a/test/Test/Notebook.hs
+++ b/test/Test/Notebook.hs
@@ -5,7 +5,14 @@ import Test.Tasty.HUnit (assertBool, assertFailure, testCase, (@?=))
 
 import qualified Data.Text as T
 
-import ScriptHs.Markdown (CodeOutput (..), MimeType (..), Segment (..))
+import ScriptHs.Markdown (
+    CodeOutput (..),
+    CodeStyle (..),
+    MimeType (..),
+    Segment (..),
+    defaultCodeStyle,
+    defaultOutputStyle,
+ )
 import ScriptHs.Notebook (
     addOutputToSegments,
     generatedMarkedScript,
@@ -151,12 +158,12 @@ notebookTests =
                             , CodeBlock
                                 "hs"
                                 "print 3\n"
-                                (Just $ CodeOutput MimePlain "old-should-be-replaced")
+                                (Just $ CodeOutput defaultOutputStyle MimePlain "old-should-be-replaced")
                             )
                         , (4, Prose "outro\n")
                         ]
 
-                let result = addOutputToSegments outputs indexedSegs
+                let result = addOutputToSegments defaultOutputStyle outputs indexedSegs
 
                 length result @?= length indexedSegs
 
@@ -164,8 +171,15 @@ notebookTests =
                 result !! 4 @?= Prose "outro\n"
 
                 result !! 1
-                    @?= CodeBlock "haskell" "print 1\n" (Just $ CodeOutput MimePlain "out-1")
-                result !! 3 @?= CodeBlock "hs" "print 3\n" (Just $ CodeOutput MimePlain "out-3")
+                    @?= CodeBlock
+                        "haskell"
+                        "print 1\n"
+                        (Just $ CodeOutput defaultOutputStyle MimePlain "out-1")
+                result !! 3
+                    @?= CodeBlock
+                        "hs"
+                        "print 3\n"
+                        (Just $ CodeOutput defaultOutputStyle MimePlain "out-3")
 
                 result !! 2 @?= CodeBlock "python" "print('x')\n" Nothing
             ]
@@ -231,7 +245,8 @@ notebookTests =
             "processNotebook"
             [ testCase "no code blocks => returns input unchanged" $ do
                 let input = T.unlines ["# Title", "", "Just prose.", ""]
-                out <- processNotebook defaultRunOptions "" input
+                out <-
+                    processNotebook defaultOutputStyle defaultCodeStyle defaultRunOptions "" input
                 out @?= input
             , testCase "non-haskell code blocks only => returns input unchanged" $ do
                 let input =
@@ -244,7 +259,8 @@ notebookTests =
                             , ""
                             , "more prose"
                             ]
-                out <- processNotebook defaultRunOptions "" input
+                out <-
+                    processNotebook defaultOutputStyle defaultCodeStyle defaultRunOptions "" input
                 out @?= input
             ]
         , testGroup
@@ -265,4 +281,23 @@ notebookTests =
                 let out = "real data: " <> mkMarker tn 5
                 scrubCellOutput tn [0] out @?= out
             ]
+        , testGroup
+            "Code style"
+            [ testCase "Removed code in final output" $ do
+                let input =
+                        T.unlines
+                            [ "# Title"
+                            , "```haskell"
+                            , "1 + 1"
+                            , "```"
+                            ]
+                result <-
+                    processNotebook defaultOutputStyle RemoveCode defaultRunOptions "" input
+                result
+                    @?= T.unlines
+                        [ "# Title"
+                        , "> <!-- scripths:mime text/plain -->"
+                        , "> 2"
+                        ]
+            ]
         ]