Don't set expression attributes before they're bound.

sky/framework/sky-element/sky-binder.sky

 <!--
 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 -->
 <import src="observe.sky" as="observe" />
 <import src="element-registry.sky" as="registry" />
 
 <script>
 var stagingDocument = new Document();
@@ skipping 159 matching lines @@
       directives.eventHandlers.push(name.substring(3));
       continue;
     }
 
     if (!registry.checkAttribute(tagName, name)) {
       console.error('Element "'+ tagName +
           '" has unknown attribute "' + name + '".');
     }
 
     var property = parsePropertyDirective(value, name);
-    if (!property)
-      continue;
-
-    directives.properties.push(property);
+    if (property)
+      directives.properties.push(property);
   }
 }
 
+function createCloneSource(element, properties) {
+  if (!properties.length)
+    return element;
+
+  // Leave attributes alone on template so you can see the if/repeat statements
+  // in the inspector.
+  if (element instanceof HTMLTemplateElement)
+    return element;
+
+  var result = element.cloneNode(false);
+
+  for (var i = 0; i < properties.length; ++i) {
+    result.removeAttribute(properties[i].name);
+  }
+
+  return result;
+}
+
 function eventHandlerCallback(event) {
   var element = event.currentTarget;
   var method = element.getAttribute('on-' + event.type);
   var scope = element.ownerScope;
   var host = scope.host;
   var handler = host && host[method];
   if (handler instanceof Function)
     return handler.call(host, event);
 }
 
 class NodeDirectives {
   constructor(node) {
     this.eventHandlers = [];
     this.children = [];
     this.properties = [];
     this.node = node;
+    this.cloneSourceNode = node;
     Object.preventExtensions(this);
 
     if (node instanceof Element) {
       parseAttributeDirectives(node, this);
+      this.cloneSourceNode = createCloneSource(node, this.properties);
     } else if (node instanceof Text) {
       var property = parsePropertyDirective(node.data, 'textContent');
       if (property)
         this.properties.push(property);
     }
 
     for (var child = node.firstChild; child; child = child.nextSibling) {
       this.children.push(new NodeDirectives(child));
     }
   }
   findProperty(name) {
     for (var i = 0; i < this.properties.length; ++i) {
       if (this.properties[i].name === name)
         return this.properties[i];
     }
     return null;
   }
   createBoundClone(parent, model, bindings) {
     // TODO(esprehn): In sky instead of needing to use a staging docuemnt per
     // custom element registry we're going to need to use the current module's
     // registry.
-    var clone = stagingDocument.importNode(this.node, false);
+    var clone = stagingDocument.importNode(this.cloneSourceNode, false);
 
     for (var i = 0; i < this.eventHandlers.length; ++i) {
       clone.addEventListener(this.eventHandlers[i], eventHandlerCallback);
     }
 
-    var clone = parent.appendChild(clone);
-
-    for (var i = 0; i < this.children.length; ++i) {
-      this.children[i].createBoundClone(clone, model, bindings);
-    }
-
     for (var i = 0; i < this.properties.length; ++i) {
       bindings.push(this.properties[i].bindProperty(clone, model));
     }
 
+    parent.appendChild(clone);
+
+    for (var i = 0; i < this.children.length; ++i) {
+      this.children[i].createBoundClone(clone, model, bindings);
+    }
+
     if (clone instanceof HTMLTemplateElement) {
       var iterator = new TemplateIterator(clone);
       iterator.updateDependencies(this, model);
       bindings.push(iterator);
     }
 
     return clone;
   }
 }
 
@@ skipping 217 matching lines @@
 
     iterators.delete(this.template);
     this.closed = true;
   }
 }
 
 module.exports = {
   createInstance: createInstance,
 };
 </script>