diff --git a/asdf.lisp b/asdf.lisp
index e1c5621..1eb61c8 100644
--- a/asdf.lisp
+++ b/asdf.lisp
@@ -1656,39 +1656,50 @@ recursive calls to traverse.")
 ;;;; -------------------------------------------------------------------------
 ;;;; load-op
 
-(defclass basic-load-op (operation) ())
+(defvar *compile-before-loading* t)
 
-(defclass load-op (basic-load-op) ())
+(defclass load-op (operation)
+  ((precompiledp :initform *compile-before-loading* :reader load-op-precompiledp)))
 
-(defmethod perform ((o load-op) (c cl-source-file))
-  #-ecl (mapcar #'load (input-files o c))
-  #+ecl (loop :for i :in (input-files o c)
-          :unless (string= (pathname-type i) "fas")
-          :collect (let ((output (compile-file-pathname (lispize-pathname i))))
-                     (load output))))
+(defclass load-source-op (load-op)
+  ((precompiledp :initform t)))
 
+(defmethod perform ((o load-op) (c cl-source-file))
+  (if (load-op-precompiledp o)
+      #-ecl (mapcar #'load (input-files o c))
+      #+ecl (loop :for i :in (input-files o c)
+               :unless (string= (pathname-type i) "fas")
+               :collect (let ((output (compile-file-pathname (lispize-pathname i))))
+                          (load output)))
+      (let ((source (component-pathname c)))
+        (setf (component-property c 'last-loaded-as-source)
+              (and (load source)
+                   (get-universal-time))))))
+  
 (defmethod perform-with-restarts (operation component)
   (perform operation component))
 
 (defmethod perform-with-restarts ((o load-op) (c cl-source-file))
-  (let ((state :initial))
-    (loop :until (or (eq state :success)
-                     (eq state :failure)) :do
-         (case state
-           (:recompiled
-            (setf state :failure)
-            (call-next-method)
-            (setf state :success))
-           (:failed-load
-            (setf state :recompiled)
-            (perform (make-instance 'compile-op) c))
-           (t
-            (with-simple-restart
-                (try-recompiling "Recompile ~a and try loading it again"
-                                  (component-name c))
-              (setf state :failed-load)
+  (if (load-op-precompiledp o)
+      (let ((state :initial))
+        (loop :until (or (eq state :success)
+                         (eq state :failure)) :do
+           (case state
+             (:recompiled
+              (setf state :failure)
               (call-next-method)
-              (setf state :success)))))))
+              (setf state :success))
+             (:failed-load
+              (setf state :recompiled)
+              (perform (make-instance 'compile-op) c))
+             (t
+              (with-simple-restart
+                  (try-recompiling "Recompile ~a and try loading it again"
+                                   (component-name c))
+                (setf state :failed-load)
+                (call-next-method)
+                (setf state :success))))))
+      (call-next-method)))
 
 (defmethod perform ((operation load-op) (c static-file))
   nil)
@@ -1700,42 +1711,17 @@ recursive calls to traverse.")
   nil)
 
 (defmethod component-depends-on ((operation load-op) (c component))
-  (cons (list 'compile-op (component-name c))
-        (call-next-method)))
-
-;;;; -------------------------------------------------------------------------
-;;;; load-source-op
-
-(defclass load-source-op (basic-load-op) ())
-
-(defmethod perform ((o load-source-op) (c cl-source-file))
-  (let ((source (component-pathname c)))
-    (setf (component-property c 'last-loaded-as-source)
-          (and (load source)
-               (get-universal-time)))))
-
-(defmethod perform ((operation load-source-op) (c static-file))
-  nil)
-
-(defmethod output-files ((operation load-source-op) (c component))
-  nil)
-
-;;; FIXME: we simply copy load-op's dependencies.  this is Just Not Right.
-(defmethod component-depends-on ((o load-source-op) (c component))
-  (let ((what-would-load-op-do (cdr (assoc 'load-op
-                                           (component-in-order-to c)))))
-    (mapcar (lambda (dep)
-              (if (eq (car dep) 'load-op)
-                  (cons 'load-source-op (cdr dep))
-                  dep))
-            what-would-load-op-do)))
-
-(defmethod operation-done-p ((o load-source-op) (c source-file))
-  (if (or (not (component-property c 'last-loaded-as-source))
-          (> (safe-file-write-date (component-pathname c))
-             (component-property c 'last-loaded-as-source)))
-      nil t))
-
+  (nconc (when (load-op-precompiledp operation)
+           (list (list 'compile-op (component-name c))))
+         (call-next-method)))
+
+(defmethod operation-done-p ((o load-op) (c source-file))
+  (if (load-op-precompiledp o)
+      (call-next-method)
+      (if (or (not (component-property c 'last-loaded-as-source))
+              (> (safe-file-write-date (component-pathname c))
+                 (component-property c 'last-loaded-as-source)))
+          nil t)))
 
 ;;;; -------------------------------------------------------------------------
 ;;;; test-op
@@ -1822,12 +1808,21 @@ created with the same initargs as the original one.
   (setf (documentation 'operate 'function)
         operate-docstring))
 
-(defun load-system (system &rest args &key force (verbose t) version
+(defun load-source-system (system &rest args &key force (verbose t) version
+                           &allow-other-keys)
+  "Shorthand for `(operate 'asdf:load-op system)` forcing that nothing is
+compiled. See OPERATE for details."
+  (declare (ignore force verbose version))
+  (let ((*compile-before-loading* nil))
+    (apply #'operate 'load-op system args)))
+
+(defun load-system (system &rest args &key force (verbose t) version (compile t)
                     &allow-other-keys)
   "Shorthand for `(operate 'asdf:load-op system)`. See OPERATE for
 details."
   (declare (ignore force verbose version))
-  (apply #'operate 'load-op system args))
+  (let ((*compile-before-loading* compile))
+    (apply #'operate 'load-op system (remove-keys 'compile args))))
 
 (defun compile-system (system &rest args &key force (verbose t) version
                        &allow-other-keys)
