diff --git a/action.lisp b/action.lisp
index a10019945748526c4dc00897c12b89b0c899d24a..049176b42a54661c12a62933eee449b61df8638d 100644
--- a/action.lisp
+++ b/action.lisp
@@ -119,8 +119,8 @@ You can put together sentences using this phrase."))
 
         [Note: an <operation> is an operation designator -- it can be either an
         operation name or an operation object.  Similarly, a <component> may be
-        a component name or a component object.  Finally, the degenerate case of
-        (<operation>) is treated as a no-op.]
+        a component name or a component object.  Also note that, the degenerate
+        case of (<operation>) is a no-op.]
 
       or
 
@@ -199,9 +199,9 @@ then the action (O . C) of O on component C depends on each (S . C) for S in L.
 E.g. before a component may be loaded by LOAD-OP, it must have been compiled by COMPILE-OP.
 A operation-designator designates a singleton list of the designated operation;
 a list of operation-designators designates the list of designated operations;
-NIL is not a valid operation designator in that context.  Note that orderings between 
-the operations in a list of SELWARD-OPERATION should be indicated separately in order
-that they be scheduled properly."))
+NIL is not a valid operation designator in that context.  Note that any dependency
+ordering between the operations in a list of SELFWARD-OPERATION should be specified separately
+in the respective operation's COMPONENT-DEPENDS-ON methods so that they be scheduled properly."))
   (defun selfward-operation-depends-on (o c)
     (loop :for op :in (ensure-list (selfward-operation o)) :collect `(,op ,c)))
   (defmethod component-depends-on ((o selfward-operation) (c component))
@@ -405,11 +405,11 @@ in some previous image, or T if it needs to be done.")
 
 ;;; Generic build operation
 (with-upgradability ()
-  ;; build op was intended to be the master, default operation on a system
-  ;; (LOAD-OP typically serves that function now).  This feature has not yet
-  ;; been fully implemented yet.
-  ;; This is a path forward, but is not backwardly compatible, and is not used
-  ;; yet. [2014/01/26:rpg]
+  ;; BUILD-OP was intended to be the default "master" operation to invoke on a system in ASDF3
+  ;; (LOAD-OP typically serves that function now).
+  ;; This feature has not yet been fully implemented yet, and is not used by anyone yet.
+  ;; This is a path forward, and its default below is to backward compatibly depend on LOAD-OP.
+  ;; [2014/01/26:rpg]
   (defclass build-op (non-propagating-operation) ())
   (defmethod component-depends-on ((o build-op) (c component))
     `((,(or (component-build-operation c) 'load-op) ,c))))
diff --git a/component.lisp b/component.lisp
index f129b105a3f1612d124d8cfe8a37bf58f6af1dae..33578ab2e2b66494e7f0430074b56dd5e4a84f48 100644
--- a/component.lisp
+++ b/component.lisp
@@ -138,8 +138,7 @@ another pathname in a degenerate way."))
 
   (defun component-find-path (component)
     "Return a path from a root system to the COMPONENT.
-The return value is a list of component NAMES; a list of
-strings."
+The return value is a list of component NAMES; a list of strings."
     (check-type component (or null component))
     (reverse
      (loop :for c = component :then (component-parent c)
diff --git a/lisp-action.lisp b/lisp-action.lisp
index 1e435867f4dc19a5306e863c9cf1886386f2cd91..0622c42ed08bb5ca2c01e0c76a08af1591358ec8 100644
--- a/lisp-action.lisp
+++ b/lisp-action.lisp
@@ -39,8 +39,7 @@
 (with-upgradability ()
   (defclass prepare-op (upward-operation sideway-operation)
     ((sideway-operation :initform 'load-op :allocation :class))
-    (:documentation "Load the necessary dependencies for the COMPONENT to which we apply
-the PREPARE-OP."))
+    (:documentation "Load dependencies necessary for COMPILE-OP or LOAD-OP of a given COMPONENT."))
   (defclass load-op (basic-load-op downward-operation selfward-operation)
     ;; NB: even though compile-op depends on prepare-op it is not needed-in-image-p,
     ;; so we need to directly depend on prepare-op for its side-effects in the current image.
diff --git a/operation.lisp b/operation.lisp
index d2e38a64459de4b3b145a6c15f3a23984318be9e..0c6dbb2606481a900ccb98fd9a2d7fda27f8a35d 100644
--- a/operation.lisp
+++ b/operation.lisp
@@ -57,5 +57,3 @@
     (declare (ignorable context))
     nil))
 
-
-
diff --git a/plan.lisp b/plan.lisp
index d564aec5cfc67b4ba7ab939f39fccf090e111b44..eb972f6475f02d59ac37a63904bef431ab1f3644 100644
--- a/plan.lisp
+++ b/plan.lisp
@@ -322,17 +322,18 @@ the action of OPERATION on COMPONENT in the PLAN"))
 
   (defmethod traverse-action (plan operation component needed-in-image-p)
     (block nil
-      ;; ACTION-VALID-P among other things, handles forcing logic, including
-      ;; FORCE-NOT.
+      ;; ACTION-VALID-P among other things, handles forcing logic, including FORCE-NOT,
+      ;; and IF-FEATURE filtering.
       (unless (action-valid-p plan operation component) (return nil))
-      ;; the following is needed by POIU, which tracks a dependency graph,
+      ;; the following hook is needed by POIU, which tracks a full dependency graph,
       ;; instead of just a dependency order as in vanilla ASDF
       (plan-record-dependency plan operation component)
       ;; needed in image distinguishes b/w things that must happen in the
-      ;; current image and those things that simply need to have been done.
-      (let* ((aniip (needed-in-image-p operation component))
-             ;; effectively needed in image
+      ;; current image and those things that simply need to have been done in a previous one.
+      (let* ((aniip (needed-in-image-p operation component)) ; action-specific needed-in-image
+             ;; effective niip: meaningful for the action and required by the plan as traversed
              (eniip (and aniip needed-in-image-p))
+             ;; status: have we traversed that action previously, and if so what was its status?
              (status (plan-action-status plan operation component)))
         (when (and status (or (action-done-p status) (action-planned-p status) (not eniip)))
           (return (action-stamp status))) ; Already visited with sufficient need-in-image level!
diff --git a/test/test-asdf.asd b/test/test-asdf.asd
index 0e9f97b096ae7faeb0dc36696eb86ce3fd8a11a0..fd99fc064eed1df18d94537008b8c15acb88b8d2 100644
--- a/test/test-asdf.asd
+++ b/test/test-asdf.asd
@@ -50,7 +50,7 @@
        (:file "does-not-exist"
         :in-order-to ((compile-op (feature (:not :common-lisp))))))
       :if-component-dep-fails :ignore)))))
-       
+
 
 (defsystem :test-asdf/test9-2
   :version "1.0"
diff --git a/upgrade.lisp b/upgrade.lisp
index b8a7c66f57a0263c0d5d246b29c4e5bccc7409d2..c62363ffff9ddb75bc907df2cbdb60924b8c1f40 100644
--- a/upgrade.lisp
+++ b/upgrade.lisp
@@ -51,7 +51,7 @@ You can compare this string with e.g.: (ASDF:VERSION-SATISFIES (ASDF:ASDF-VERSIO
   (defun upgrading-p ()
     (and *previous-asdf-versions* (not (equal *asdf-version* (first *previous-asdf-versions*)))))
   (defmacro when-upgrading ((&key (upgrading-p '(upgrading-p)) when) &body body)
-    "A wrapper macro for code that should only be run when upgrading a 
+    "A wrapper macro for code that should only be run when upgrading a
 previously-loaded version of ASDF."
     `(with-upgradability ()
        (when (and ,upgrading-p ,@(when when `(,when)))