diff --git a/lib/_stream_readable.js b/lib/_stream_readable.js
index ad3302e5422a01..6bc4e1ad2f2f2e 100644
--- a/lib/_stream_readable.js
+++ b/lib/_stream_readable.js
@@ -33,7 +33,10 @@ const { Buffer } = require('buffer');
 const debug = require('internal/util/debuglog').debuglog('stream');
 const BufferList = require('internal/streams/buffer_list');
 const destroyImpl = require('internal/streams/destroy');
-const { getHighWaterMark } = require('internal/streams/state');
+const {
+  getHighWaterMark,
+  getDefaultHighWaterMark
+} = require('internal/streams/state');
 const {
   ERR_INVALID_ARG_TYPE,
   ERR_STREAM_PUSH_AFTER_EOF,
@@ -70,8 +73,6 @@ function prependListener(emitter, event, fn) {
 }
 
 function ReadableState(options, stream, isDuplex) {
-  options = options || {};
-
   // Duplex streams are both readable and writable, but share
   // the same options object.
   // However, some cases require setting options to different
@@ -82,15 +83,17 @@ function ReadableState(options, stream, isDuplex) {
 
   // Object stream flag. Used to make read(n) ignore n and to
   // make all the buffer merging and length checks go away
-  this.objectMode = !!options.objectMode;
+  this.objectMode = !!(options && options.objectMode);
 
   if (isDuplex)
-    this.objectMode = this.objectMode || !!options.readableObjectMode;
+    this.objectMode = this.objectMode ||
+      !!(options && options.readableObjectMode);
 
   // The point at which it stops calling _read() to fill the buffer
   // Note: 0 is a valid value, means "don't call _read preemptively ever"
-  this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark',
-                                        isDuplex);
+  this.highWaterMark = options ?
+    getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex) :
+    getDefaultHighWaterMark(false);
 
   // A linked list is used to store data chunks instead of an array because the
   // linked list can remove elements from the beginning faster than
@@ -119,10 +122,10 @@ function ReadableState(options, stream, isDuplex) {
   this.paused = true;
 
   // Should close be emitted on destroy. Defaults to true.
-  this.emitClose = options.emitClose !== false;
+  this.emitClose = !options || options.emitClose !== false;
 
   // Should .destroy() be called after 'end' (and potentially 'finish')
-  this.autoDestroy = !!options.autoDestroy;
+  this.autoDestroy = !!(options && options.autoDestroy);
 
   // Has it been destroyed
   this.destroyed = false;
@@ -130,7 +133,7 @@ function ReadableState(options, stream, isDuplex) {
   // Crypto is kind of old and crusty.  Historically, its default string
   // encoding is 'binary' so we have to make this configurable.
   // Everything else in the universe uses 'utf8', though.
-  this.defaultEncoding = options.defaultEncoding || 'utf8';
+  this.defaultEncoding = (options && options.defaultEncoding) || 'utf8';
 
   // The number of writers that are awaiting a drain event in .pipe()s
   this.awaitDrain = 0;
@@ -140,7 +143,7 @@ function ReadableState(options, stream, isDuplex) {
 
   this.decoder = null;
   this.encoding = null;
-  if (options.encoding) {
+  if (options && options.encoding) {
     if (!StringDecoder)
       StringDecoder = require('string_decoder').StringDecoder;
     this.decoder = new StringDecoder(options.encoding);
diff --git a/lib/_stream_writable.js b/lib/_stream_writable.js
index 5b8cc42d1814fc..8c21bf9c5238da 100644
--- a/lib/_stream_writable.js
+++ b/lib/_stream_writable.js
@@ -34,7 +34,10 @@ const internalUtil = require('internal/util');
 const Stream = require('stream');
 const { Buffer } = require('buffer');
 const destroyImpl = require('internal/streams/destroy');
-const { getHighWaterMark } = require('internal/streams/state');
+const {
+  getHighWaterMark,
+  getDefaultHighWaterMark
+} = require('internal/streams/state');
 const {
   ERR_INVALID_ARG_TYPE,
   ERR_METHOD_NOT_IMPLEMENTED,
@@ -54,8 +57,6 @@ Object.setPrototypeOf(Writable, Stream);
 function nop() {}
 
 function WritableState(options, stream, isDuplex) {
-  options = options || {};
-
   // Duplex streams are both readable and writable, but share
   // the same options object.
   // However, some cases require setting options to different
@@ -66,16 +67,18 @@ function WritableState(options, stream, isDuplex) {
 
   // Object stream flag to indicate whether or not this stream
   // contains buffers or objects.
-  this.objectMode = !!options.objectMode;
+  this.objectMode = !!(options && options.objectMode);
 
   if (isDuplex)
-    this.objectMode = this.objectMode || !!options.writableObjectMode;
+    this.objectMode = this.objectMode ||
+      !!(options && options.writableObjectMode);
 
   // The point at which write() starts returning false
   // Note: 0 is a valid value, means that we always return false if
   // the entire buffer is not flushed immediately on write()
-  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark',
-                                        isDuplex);
+  this.highWaterMark = options ?
+    getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex) :
+    getDefaultHighWaterMark(false);
 
   // if _final has been called
   this.finalCalled = false;
@@ -95,13 +98,13 @@ function WritableState(options, stream, isDuplex) {
   // Should we decode strings into buffers before passing to _write?
   // this is here so that some node-core streams can optimize string
   // handling at a lower level.
-  const noDecode = options.decodeStrings === false;
+  const noDecode = !!(options && options.decodeStrings === false);
   this.decodeStrings = !noDecode;
 
   // Crypto is kind of old and crusty.  Historically, its default string
   // encoding is 'binary' so we have to make this configurable.
   // Everything else in the universe uses 'utf8', though.
-  this.defaultEncoding = options.defaultEncoding || 'utf8';
+  this.defaultEncoding = (options && options.defaultEncoding) || 'utf8';
 
   // Not an actual buffer we keep track of, but a measurement
   // of how much we're waiting to get pushed to some underlying
@@ -149,10 +152,10 @@ function WritableState(options, stream, isDuplex) {
   this.errorEmitted = false;
 
   // Should close be emitted on destroy. Defaults to true.
-  this.emitClose = options.emitClose !== false;
+  this.emitClose = !options || options.emitClose !== false;
 
   // Should .destroy() be called after 'finish' (and potentially 'end')
-  this.autoDestroy = !!options.autoDestroy;
+  this.autoDestroy = !!(options && options.autoDestroy);
 
   // Count buffered requests
   this.bufferedRequestCount = 0;