diff --git a/README.md b/README.md
index 090fce0f..65fac502 100644
--- a/README.md
+++ b/README.md
@@ -48,7 +48,7 @@ This branch contains a preview of the Polymer 2.0 library.  The codebase is unde
 
    * Changes are now batched, and the effects of those changes are run in well-defined order.
    * We ensure that multi-property observers run exactly once per turn for any set of changes to dependencies (removing the [multi-property undefined rule](https://www.polymer-project.org/1.0/docs/devguide/observers#multi-property-observers)).
-   * To improve compatibility with top-down data-flow approaches (e.g. Flux), we now provide a mixin (and legacy behavior) to skip dirty-checking properties whose values are objects or arrays.
+   * To add compatibility with more approaches to state management, we now provide a mixin (and legacy behavior) to skip dirty-checking properties whose values are objects or arrays and always consider them dirty, causing their side effects to run.
 
 1. **Improve factoring of Polymer and the polyfills**
 
@@ -245,7 +245,7 @@ Polymer 2.0 will continue to use a [shim](https://github.com/webcomponents/shady
 * <a name="breaking-binding-notifications>‘notify’ events are no longer fired when value changes _as result of binding from host_, as a major performance optimization over 1.x behavior.  Use cases such as `<my-el foo="{{bar}}" on-foo-changed="fooChanged">` are no longer supported.  In this case you should simply user a `bar` observer in the host.  Use cases such as dynamically adding a `property-changed` event listener on for properties bound by an element's host by an actor other than the host are no longer supported.
 * <a name="breaking-properties-deserialization"></a>In order for a property to be deserialized from its attribute, it must be declared in the `properties` metadata object
 * <a name="breaking-colleciton"></a>The `Polymer.Collection` and associated key-based path and splice notification for arrays has been eliminated.  See [explanation here](https://github.com/Polymer/polymer/pull/3970#issue-178203286) for more details.
-* <a name="feature-mutable-data"></a>While not a breaking change, Polymer now ships with a `Polymer.MutableData` mixin (and legacy `Polymer.MutableDataBehavior` behavior) to provide more options for managing data.  By default, `Polymer.PropertyEffects` performs strict dirty checking on objects, which means that any deep modifications to an object or array will not be propagated unless "immutable" data patterns are used (i.e. all object references from the root to the mutation were changed).  Polymer also provides a proprietary data mutation and path notification API (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient mutation and notification of deep changes in an object graph to all elements bound to the same object graph. In cases where neither immutable patterns or the data mutation API can be used, applying this mixin will cause Polymer to skip dirty checking for objects and arrays.  This allows a user to make a deep modification to a bound object graph, and then either simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath` (e.g. `this.notifyPath('items')`) to update the tree.  Note that all elements that wish to be updated based on deep mutations must apply this mixin or otherwise skip strict dirty checking for objects/arrays.
+* <a name="feature-mutable-data"></a>While not a breaking change, Polymer now ships with a `Polymer.MutableData` mixin (and legacy `Polymer.MutableDataBehavior` behavior) to provide more options for managing data.  By default, `Polymer.PropertyEffects` performs strict dirty checking on objects, which means that any deep modifications to an object or array will not be propagated unless "immutable" data patterns are used (i.e. all object references from the root to the mutation were changed).  Polymer also provides a proprietary data mutation and path notification API (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient mutation and notification of deep changes in an object graph to all elements bound to the same object graph. In cases where neither immutable patterns or the data mutation API can be used, applying this mixin will cause Polymer to skip dirty checking for objects and arrays and always consider them to be "dirty".  This allows a user to make a deep modification to a bound object graph, and then either simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath` (e.g. `this.notifyPath('items')`) to update the tree.  Note that all elements that wish to be updated based on deep mutations must apply this mixin or otherwise skip strict dirty checking for objects/arrays.
 
 ### Removed API
 * <a name="breaking-instanceof"></a>`Polymer.instanceof` and `Polymer.isInstance`: no longer needed, use
diff --git a/lib/legacy/mutable-data-behavior.html b/lib/legacy/mutable-data-behavior.html
index 0b6a477c..b659d69b 100644
--- a/lib/legacy/mutable-data-behavior.html
+++ b/lib/legacy/mutable-data-behavior.html
@@ -17,7 +17,7 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
 
   /**
    * Legacy element behavior to skip strict dirty-checking for objects and arrays,
-   * for use on elements utilizing `Polymer.PropertyEffects`
+   * (always consider them to be "dirty") for use on legacy API Polymer elements.
    *
    * By default, `Polymer.PropertyEffects` performs strict dirty checking on
    * objects, which means that any deep modifications to an object or array will
@@ -31,9 +31,9 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
    *
    * In cases where neither immutable patterns or the data mutation API can be
    * used, applying this mixin will allow Polymer to skip dirty checking for
-   * objects and arrays.  This allows a user to make a deep modification to a
-   * bound object graph, and then either simply re-set the object (e.g.
-   * `this.items = this.items`) or call `notifyPath`
+   * objects and arrays (always consider them to be "dirty").  This allows a
+   * user to make a deep modification to a bound object graph, and then either
+   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
    * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
    * elements that wish to be updated based on deep mutations must apply this
    * mixin or otherwise skip strict dirty checking for objects/arrays.
@@ -79,17 +79,10 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
      * same object (using the temp cache as an in-turn backstop to prevent
      * cycles due to 2-way notification).
      *
-     * Users may override this method and call super setting `useObjectIdentity`
-     * to `true` to fall back to strict dirty checking if the mutable nature
-     * requires configurability.
-     *
      * @param {string} property Property name
      * @param {*} value New property value
      * @param {*} old Previous property value
-     * @param {boolean} useObjectIdentity When true, the method falls back
-     *   to using strict object identity dirty checking
      * @return {boolean} Whether the property should be considered a change
-     *   and enqueue a `_proeprtiesChanged` callback
      * @protected
      */
     _shouldPropertyChange(property, value, old) {
diff --git a/lib/mixins/mutable-data.html b/lib/mixins/mutable-data.html
index 4a6fd6cb..bc857610 100644
--- a/lib/mixins/mutable-data.html
+++ b/lib/mixins/mutable-data.html
@@ -33,7 +33,8 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
 
   /**
    * Element class mixin to add the ability to skip strict dirty-checking for
-   * objects and arrays, for use on elements utilizing `Polymer.PropertyEffects`
+   * objects and arrays (always consider them to be "dirty"), for use on
+   * elements utilizing `Polymer.PropertyEffects`
    *
    * By default, `Polymer.PropertyEffects` performs strict dirty checking on
    * objects, which means that any deep modifications to an object or array will
@@ -47,9 +48,9 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
    *
    * In cases where neither immutable patterns or the data mutation API can be
    * used, applying this mixin will allow Polymer to skip dirty checking for
-   * objects and arrays.  This allows a user to make a deep modification to a
-   * bound object graph, and then either simply re-set the object (e.g.
-   * `this.items = this.items`) or call `notifyPath`
+   * objects and arrays (always consider them to be "dirty").  This allows a
+   * user to make a deep modification to a bound object graph, and then either
+   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
    * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
    * elements that wish to be updated based on deep mutations must apply this
    * mixin or otherwise skip strict dirty checking for objects/arrays.
@@ -102,15 +103,10 @@ subject to an additional IP rights grant found at http://polymer.github.io/PATEN
        * same object (using the temp cache as an in-turn backstop to prevent
        * cycles due to 2-way notification).
        *
-       * Users may override this method and call super setting `useObjectIdentity`
-       * to `true` to fall back to strict dirty checking if the mutable nature
-       * requires configurability.
-       *
        * @param {string} property Property name
        * @param {*} value New property value
        * @param {*} old Previous property value
        * @return {boolean} Whether the property should be considered a change
-       *   and enqueue a `_proeprtiesChanged` callback
        * @protected
        */
       _shouldPropertyChange(property, value, old) {