diff --git a/02_strings.clj b/02_strings.clj
index af4e555..21a71e5 100644
--- a/02_strings.clj
+++ b/02_strings.clj
@@ -1,70 +1,66 @@
-(ns koans.02-strings
-  (:require [koan-engine.core :refer :all]
-            [clojure.string :as string]))
 
-(meditations
-  "A string is nothing more than text surrounded by double quotes"
+  ; "A string is nothing more than text surrounded by double quotes"
   (= __ "hello")
 
-  "But double quotes are just magic on top of something deeper"
+  ; "But double quotes are just magic on top of something deeper"
   (= __ (str 'world))
 
-  "You can do more than create strings, you can put them together"
+  ; "You can do more than create strings, you can put them together"
   (= "Cool right?" (str __ __))
 
-  "You can even get certain characters"
+  ; "You can even get certain characters"
   (= \C (get "Characters" __))
 
-  "Or even count the characters"
+  ; "Or even count the characters"
   (= __ (count "Hello World"))
 
-  "But strings and characters are not the same"
+  ; "But strings and characters are not the same"
   (= __ (= \c "c"))
 
-  "What if you only wanted to get part of a string?"
+  ; "What if you only wanted to get part of a string?"
   (= "World" (subs "Hello World" __ __))
 
-  "How about joining together elements in a list?"
+  ; "How about joining together elements in a list?"
   (= __ (string/join '(1 2 3)))
 
-  "What if you wanted to separate them out?"
+  ; "What if you wanted to separate them out?"
   (= "1, 2, 3" (string/join __ '(1 2 3)))
 
-  "Maybe you want to separate out all your lines"
+  ; "Maybe you want to separate out all your lines"
   (= [__ __ __] (string/split-lines "1\n2\n3"))
 
-  "You may want to make sure your words are backwards"
+  ; "You may want to make sure your words are backwards"
   (= __ (string/reverse "hello"))
 
-  "Maybe you want to find the index of the first occurence of a substring"
+  ; "Maybe you want to find the index of the first occurence of a substring"
   (= 0 (string/index-of "hello world" __))
 
-  "Or maybe the last index of the same"
+  ; "Or maybe the last index of the same"
   (= __ (string/last-index-of "hello world, hello" "hello"))
 
-  "But when something doesn't exist, nothing is found"
+  ; "But when something doesn't exist, nothing is found"
   (= __ (string/index-of "hello world" "bob"))
 
-  "Sometimes you don't want whitespace cluttering the front and back"
+  ; "Sometimes you don't want whitespace cluttering the front and back"
   (= __ (string/trim "  \nhello world \t \n"))
 
-  "You can check if something is a char"
+  ; "You can check if something is a char"
   (= __ (char? \c))
 
-  "But it may not be"
+  ; "But it may not be"
   (= __ (char? "a"))
 
-  "But chars aren't strings"
+  ; "But chars aren't strings"
   (= __ (string? \b))
 
-  "Strings are strings"
+  ; "Strings are strings"
   (= true (string? __))
 
-  "Some strings may be blank"
+  ; "Some strings may be blank"
   (= __ (string/blank? ""))
 
-  "Even if at first glance they aren't"
+  ; "Even if at first glance they aren't"
   (= __ (string/blank? " \n \t  "))
 
-  "However, most strings aren't blank"
-  (= __ (string/blank? "hello?\nare you out there?")))
+  ; "However, most strings aren't blank"
+  (= __ (string/blank? "hello?\nare you out there?"))
diff --git a/03_lists.clj b/03_lists.clj
index dbdf6f5..adb3ae0 100644
--- a/03_lists.clj
+++ b/03_lists.clj
@@ -1,45 +1,42 @@
-(ns koans.03-lists
-  (:require [koan-engine.core :refer :all]))
 
-(meditations
-  "Lists can be expressed by function or a quoted form"
+  ; "Lists can be expressed by function or a quoted form"
   (= '(__ __ __ __ __) (list 1 2 3 4 5))
 
-  "They are Clojure seqs (sequences), so they allow access to the first"
+  ; "They are Clojure seqs (sequences), so they allow access to the first"
   (= __ (first '(1 2 3 4 5)))
 
-  "As well as the rest"
+  ; "As well as the rest"
   (= __ (rest '(1 2 3 4 5)))
 
-  "Count your blessings"
+  ; "Count your blessings"
   (= __ (count '(dracula dooku chocula)))
 
-  "Before they are gone"
+  ; "Before they are gone"
   (= __ (count '()))
 
-  "The rest, when nothing is left, is empty"
+  ; "The rest, when nothing is left, is empty"
   (= __ (rest '(100)))
 
-  "Construction by adding an element to the front is easy"
+  ; "Construction by adding an element to the front is easy"
   (= __ (cons :a '(:b :c :d :e)))
 
-  "Conjoining an element to a list isn't hard either"
+  ; "Conjoining an element to a list isn't hard either"
   (= __ (conj '(:a :b :c :d) :e))
 
-  "You can use a list like a stack to get the first element"
+  ; "You can use a list like a stack to get the first element"
   (= __ (peek '(:a :b :c :d :e)))
 
-  "Or the others"
+  ; "Or the others"
   (= __ (pop '(:a :b :c :d :e)))
 
-  "But watch out if you try to pop nothing"
+  ; "But watch out if you try to pop nothing"
   (= __ (try
           (pop '())
           (catch IllegalStateException e
             "No dice!")))
 
-  "The rest of nothing isn't so strict"
+  ; "The rest of nothing isn't so strict"
   (= __ (try
           (rest '())
           (catch IllegalStateException e
-            "No dice!"))))
+            "No dice!")))
diff --git a/04_vectors.clj b/04_vectors.clj
index 71970f6..2c87c4e 100644
--- a/04_vectors.clj
+++ b/04_vectors.clj
@@ -1,33 +1,30 @@
-(ns koans.04-vectors
-  (:require [koan-engine.core :refer :all]))
 
-(meditations
-  "You can use vectors in clojure as array-like structures"
+  ; "You can use vectors in clojure as array-like structures"
   (= __ (count [42]))
 
-  "You can create a vector from a list"
+  ; "You can create a vector from a list"
   (= __ (vec '(1)))
 
-  "Or from some elements"
+  ; "Or from some elements"
   (= __ (vector nil nil))
 
-  "But you can populate it with any number of elements at once"
+  ; "But you can populate it with any number of elements at once"
   (= [1 __] (vec '(1 2)))
 
-  "Conjoining to a vector is different than to a list"
+  ; "Conjoining to a vector is different than to a list"
   (= __ (conj [111 222] 333))
 
-  "You can get the first element of a vector like so"
+  ; "You can get the first element of a vector like so"
   (= __ (first [:peanut :butter :and :jelly]))
 
-  "And the last in a similar fashion"
+  ; "And the last in a similar fashion"
   (= __ (last [:peanut :butter :and :jelly]))
 
-  "Or any index if you wish"
+  ; "Or any index if you wish"
   (= __ (nth [:peanut :butter :and :jelly] 3))
 
-  "You can also slice a vector"
+  ; "You can also slice a vector"
   (= __ (subvec [:peanut :butter :and :jelly] 1 3))
 
-  "Equality with collections is in terms of values"
-  (= (list 1 2 3) (vector 1 2 __)))
+  ; "Equality with collections is in terms of values"
+  (= (list 1 2 3) (vector 1 2 __))
diff --git a/05_sets.clj b/05_sets.clj
index a6e631f..744cd4d 100644
--- a/05_sets.clj
+++ b/05_sets.clj
@@ -1,22 +1,18 @@
-(ns koans.05-sets
-  (:require [koan-engine.core :refer :all]
-            [clojure.set :as set]))
 
-(meditations
-  "You can create a set by converting another collection"
+  ; "You can create a set by converting another collection"
   (= #{3} (set __))
 
-  "Counting them is like counting other collections"
+  ; "Counting them is like counting other collections"
   (= __ (count #{1 2 3}))
 
-  "Remember that a set is a *mathematical* set"
+  ; "Remember that a set is a *mathematical* set"
   (= __ (set '(1 1 2 2 3 3 4 4 5 5)))
 
-  "You can ask clojure for the union of two sets"
+  ; "You can ask clojure for the union of two sets"
   (= __ (set/union #{1 2 3 4} #{2 3 5}))
 
-  "And also the intersection"
+  ; "And also the intersection"
   (= __ (set/intersection #{1 2 3 4} #{2 3 5}))
 
-  "But don't forget about the difference"
-  (= __ (set/difference #{1 2 3 4 5} #{2 3 5})))
+  ; "But don't forget about the difference"
+  (= __ (set/difference #{1 2 3 4 5} #{2 3 5}))
diff --git a/06_maps.clj b/06_maps.clj
index 3466864..b9f8b61 100644
--- a/06_maps.clj
+++ b/06_maps.clj
@@ -1,50 +1,47 @@
-(ns koans.06-maps
-  (:require [koan-engine.core :refer :all]))
 
-(meditations
-  "Don't get lost when creating a map"
+  ; "Don't get lost when creating a map"
   (= {:a 1 :b 2} (hash-map :a 1 __ __))
 
-  "A value must be supplied for each key"
+  ; "A value must be supplied for each key"
   (= {:a 1} (hash-map :a __))
 
-  "The size is the number of entries"
+  ; "The size is the number of entries"
   (= __ (count {:a 1 :b 2}))
 
-  "You can look up the value for a given key"
+  ; "You can look up the value for a given key"
   (= __ (get {:a 1 :b 2} :b))
 
-  "Maps can be used as functions to do lookups"
+  ; "Maps can be used as functions to do lookups"
   (= __ ({:a 1 :b 2} :a))
 
-  "And so can keywords"
+  ; "And so can keywords"
   (= __ (:a {:a 1 :b 2}))
 
-  "But map keys need not be keywords"
+  ; "But map keys need not be keywords"
   (= __ ({2010 "Vancouver" 2014 "Sochi" 2018 "PyeongChang"} 2014))
 
-  "You may not be able to find an entry for a key"
+  ; "You may not be able to find an entry for a key"
   (= __ (get {:a 1 :b 2} :c))
 
-  "But you can provide your own default"
+  ; "But you can provide your own default"
   (= __ (get {:a 1 :b 2} :c :key-not-found))
 
-  "You can find out if a key is present"
+  ; "You can find out if a key is present"
   (= __ (contains? {:a nil :b nil} :b))
 
-  "Or if it is missing"
+  ; "Or if it is missing"
   (= __ (contains? {:a nil :b nil} :c))
 
-  "Maps are immutable, but you can create a new and improved version"
+  ; "Maps are immutable, but you can create a new and improved version"
   (= {1 "January" 2 __} (assoc {1 "January"} 2 "February"))
 
-  "You can also create a new version with an entry removed"
+  ; "You can also create a new version with an entry removed"
   (= {__ __} (dissoc {1 "January" 2 "February"} 2))
 
-  "Often you will need to get the keys, but the order is undependable"
+  ; "Often you will need to get the keys, but the order is undependable"
   (= (list __ __ __)
      (sort (keys { 2014 "Sochi" 2018 "PyeongChang" 2010 "Vancouver"})))
 
-  "You can get the values in a similar way"
+  ; "You can get the values in a similar way"
   (= (list __ __ __)
-     (sort (vals {2010 "Vancouver" 2014 "Sochi" 2018 "PyeongChang"}))))
+     (sort (vals {2010 "Vancouver" 2014 "Sochi" 2018 "PyeongChang"})))
diff --git a/07_functions.clj b/07_functions.clj
index 4bf40a0..c54bfd6 100644
--- a/07_functions.clj
+++ b/07_functions.clj
@@ -1,40 +1,32 @@
-(ns koans.07-functions
-  (:require [koan-engine.core :refer :all]))
 
-(defn multiply-by-ten [n]
-  (* 10 n))
-
-(defn square [n] (* n n))
-
-(meditations
-  "Calling a function is like giving it a hug with parentheses"
+  ; "Calling a function is like giving it a hug with parentheses"
   (= __ (square 9))
 
-  "Functions are usually defined before they are used"
+  ; "Functions are usually defined before they are used"
   (= __ (multiply-by-ten 2))
 
-  "But they can also be defined inline"
+  ; "But they can also be defined inline"
   (= __ ((fn [n] (* 5 n)) 2))
 
-  "Or using an even shorter syntax"
+  ; "Or using an even shorter syntax"
   (= __ (#(* 15 %) 4))
 
-  "Even anonymous functions may take multiple arguments"
+  ; "Even anonymous functions may take multiple arguments"
   (= __ (#(+ %1 %2 %3) 4 5 6))
 
-  "Arguments can also be skipped"
+  ; "Arguments can also be skipped"
   (= __ (#(* 15 %2) 1 2))
 
-  "One function can beget another"
+  ; "One function can beget another"
   (= 9 (((fn [] ___)) 4 5))
 
-  "Functions can also take other functions as input"
+  ; "Functions can also take other functions as input"
   (= 20 ((fn [f] (f 4 5))
            ___))
 
-  "Higher-order functions take function arguments"
+  ; "Higher-order functions take function arguments"
   (= 25 (___
           (fn [n] (* n n))))
 
-  "But they are often better written using the names of functions"
-  (= 25 (___ square)))
+  ; "But they are often better written using the names of functions"
+  (= 25 (___ square))
diff --git a/08_conditionals.clj b/08_conditionals.clj
index 87b9fdf..6681c91 100644
--- a/08_conditionals.clj
+++ b/08_conditionals.clj
@@ -1,47 +1,37 @@
-(ns koans.08-conditionals
-  (:require [koan-engine.core :refer :all]))
 
-(defn explain-exercise-velocity [exercise-term]
-  (case exercise-term
-        :bicycling        "pretty fast"
-        :jogging          "not super fast"
-        :walking          "not fast at all"
-        "is that even exercise?"))
-
-(meditations
-  "You will face many decisions"
+  ; "You will face many decisions"
   (= __ (if (false? (= 4 5))
           :a
           :b))
 
-  "Some of them leave you no alternative"
+  ; "Some of them leave you no alternative"
   (= __ (if (> 4 3)
           []))
 
-  "And in such a situation you may have nothing"
+  ; "And in such a situation you may have nothing"
   (= __ (if (nil? 0)
           [:a :b :c]))
 
-  "In others your alternative may be interesting"
+  ; "In others your alternative may be interesting"
   (= :glory (if (not (empty? ()))
               :doom
               __))
 
-  "You may have a multitude of possible paths"
+  ; "You may have a multitude of possible paths"
   (let [x 5]
     (= :your-road (cond (= x __) :road-not-taken
                         (= x __) :another-road-not-taken
                         :else __)))
 
-  "Or your fate may be sealed"
+  ; "Or your fate may be sealed"
   (= 'doom (if-not (zero? __)
           'doom
           'more-doom))
 
-  "In case of emergency, go fast"
+  ; "In case of emergency, go fast"
   (= "pretty fast"
      (explain-exercise-velocity __))
 
-  "But admit it when you don't know what to do"
+  ; "But admit it when you don't know what to do"
   (= __
-     (explain-exercise-velocity :watching-tv)))
+     (explain-exercise-velocity :watching-tv))
diff --git a/09_higher_order_functions.clj b/09_higher_order_functions.clj
index 8b7fd3c..7565b0a 100644
--- a/09_higher_order_functions.clj
+++ b/09_higher_order_functions.clj
@@ -1,35 +1,32 @@
-(ns koans.09-higher-order-functions
-  (:require [koan-engine.core :refer :all]))
 
-(meditations
-  "The map function relates a sequence to another"
+  ; "The map function relates a sequence to another"
   (= [__ __ __] (map (fn [x] (* 4 x)) [1 2 3]))
 
-  "You may create that mapping"
+  ; "You may create that mapping"
   (= [1 4 9 16 25] (map (fn [x] __) [1 2 3 4 5]))
 
-  "Or use the names of existing functions"
+  ; "Or use the names of existing functions"
   (= __ (map nil? [:a :b nil :c :d]))
 
-  "A filter can be strong"
+  ; "A filter can be strong"
   (= __ (filter (fn [x] false) '(:anything :goes :here)))
 
-  "Or very weak"
+  ; "Or very weak"
   (= __ (filter (fn [x] true) '(:anything :goes :here)))
 
-  "Or somewhere in between"
+  ; "Or somewhere in between"
   (= [10 20 30] (filter (fn [x] __) [10 20 30 40 50 60 70 80]))
 
-  "Maps and filters may be combined"
+  ; "Maps and filters may be combined"
   (= [10 20 30] (map (fn [x] __) (filter (fn [x] __) [1 2 3 4 5 6 7 8])))
 
-  "Reducing can increase the result"
+  ; "Reducing can increase the result"
   (= __ (reduce (fn [a b] (* a b)) [1 2 3 4]))
 
-  "You can start somewhere else"
+  ; "You can start somewhere else"
   (= 2400 (reduce (fn [a b] (* a b)) __ [1 2 3 4]))
 
-  "Numbers are not the only things one can reduce"
+  ; "Numbers are not the only things one can reduce"
   (= "longest" (reduce (fn [a b]
                          (if (< __ __) b a))
-                       ["which" "word" "is" "longest"])))
+                       ["which" "word" "is" "longest"]))
diff --git a/10_runtime_polymorphism.clj b/10_runtime_polymorphism.clj
index 8be1c6a..18a4989 100644
--- a/10_runtime_polymorphism.clj
+++ b/10_runtime_polymorphism.clj
@@ -1,42 +1,26 @@
-(ns koans.10-runtime-polymorphism
-  (:require [koan-engine.core :refer :all]))
 
-(defn hello
-  ([] "Hello World!")
-  ([a] (str "Hello, you silly " a "."))
-  ([a & more] (str "Hello to this group: "
-                   (apply str
-                          (interpose ", " (cons a more)))
-                   "!")))
-
-(defmulti diet (fn [x] (:eater x)))
-(defmethod diet :herbivore [a] __)
-(defmethod diet :carnivore [a] __)
-(defmethod diet :default [a] __)
-
-(meditations
-  "Some functions can be used in different ways - with no arguments"
+  ; "Some functions can be used in different ways - with no arguments"
   (= __ (hello))
 
-  "With one argument"
+  ; "With one argument"
   (= __ (hello "world"))
 
-  "Or with many arguments"
+  ; "Or with many arguments"
   (= __
      (hello "Peter" "Paul" "Mary"))
 
-  "Multimethods allow more complex dispatching"
+  ; "Multimethods allow more complex dispatching"
   (= "Bambi eats veggies."
      (diet {:species "deer" :name "Bambi" :age 1 :eater :herbivore}))
 
-  "Animals have different names"
+  ; "Animals have different names"
   (= "Thumper eats veggies."
      (diet {:species "rabbit" :name "Thumper" :age 1 :eater :herbivore}))
 
-  "Different methods are used depending on the dispatch function result"
+  ; "Different methods are used depending on the dispatch function result"
   (= "Simba eats animals."
      (diet {:species "lion" :name "Simba" :age 1 :eater :carnivore}))
 
-  "You may use a default method when no others match"
+  ; "You may use a default method when no others match"
   (= "I don't know what Rich Hickey eats."
-     (diet {:name "Rich Hickey"})))
+     (diet {:name "Rich Hickey"}))
diff --git a/11_lazy_sequences.clj b/11_lazy_sequences.clj
index 1023785..dfba1d6 100644
--- a/11_lazy_sequences.clj
+++ b/11_lazy_sequences.clj
@@ -1,28 +1,25 @@
-(ns koans.11-lazy-sequences
-  (:require [koan-engine.core :refer :all]))
 
-(meditations
-  "There are many ways to generate a sequence"
+  ; "There are many ways to generate a sequence"
   (= __ (range 1 5))
 
-  "The range starts at the beginning by default"
+  ; "The range starts at the beginning by default"
   (= __ (range 5))
 
-  "Only take what you need when the sequence is large"
+  ; "Only take what you need when the sequence is large"
   (= [0 1 2 3 4 5 6 7 8 9]
      (take __ (range 100)))
 
-  "Or limit results by dropping what you don't need"
+  ; "Or limit results by dropping what you don't need"
   (= [95 96 97 98 99]
      (drop __ (range 100)))
 
-  "Iteration provides an infinite lazy sequence"
+  ; "Iteration provides an infinite lazy sequence"
   (= __ (take 20 (iterate inc 0)))
 
-  "Repetition is key"
+  ; "Repetition is key"
   (= [:a :a :a :a :a :a :a :a :a :a]
      (repeat 10 __))
 
-  "Iteration can be used for repetition"
+  ; "Iteration can be used for repetition"
   (= (repeat 100 :hello)
-     (take 100 (iterate ___ :hello))))
+     (take 100 (iterate ___ :hello)))
diff --git a/12_sequence_comprehensions.clj b/12_sequence_comprehensions.clj
index f131e1a..3c2506b 100644
--- a/12_sequence_comprehensions.clj
+++ b/12_sequence_comprehensions.clj
@@ -1,36 +1,33 @@
-(ns koans.12-sequence-comprehensions
-  (:require [koan-engine.core :refer :all]))
 
-(meditations
-  "Sequence comprehensions can bind each element in turn to a symbol"
+  ; "Sequence comprehensions can bind each element in turn to a symbol"
   (= __
      (for [x (range 6)]
        x))
 
-  "They can easily emulate mapping"
+  ; "They can easily emulate mapping"
   (= '(0 1 4 9 16 25)
      (map (fn [x] (* x x))
           (range 6))
      (for [x (range 6)]
        __))
 
-  "And also filtering"
+  ; "And also filtering"
   (= '(1 3 5 7 9)
      (filter odd? (range 10))
      (for [x __ :when (odd? x)]
        x))
 
-  "Combinations of these transformations is trivial"
+  ; "Combinations of these transformations is trivial"
   (= '(1 9 25 49 81)
      (map (fn [x] (* x x))
           (filter odd? (range 10)))
      (for [x (range 10) :when __]
        __))
 
-  "More complex transformations simply take multiple binding forms"
+  ; "More complex transformations simply take multiple binding forms"
   (= [[:top :left] [:top :middle] [:top :right]
       [:middle :left] [:middle :middle] [:middle :right]
       [:bottom :left] [:bottom :middle] [:bottom :right]]
      (for [row [:top :middle :bottom]
            column [:left :middle :right]]
-       __)))
+       __))
diff --git a/13_creating_functions.clj b/13_creating_functions.clj
index 7d84bc8..c5cac97 100644
--- a/13_creating_functions.clj
+++ b/13_creating_functions.clj
@@ -1,35 +1,30 @@
-(ns koans.13-creating-functions
-  (:require [koan-engine.core :refer :all]))
 
-(defn square [x] (* x x))
-
-(meditations
-  "One may know what they seek by knowing what they do not seek"
+  ; "One may know what they seek by knowing what they do not seek"
   (= [__ __ __] (let [not-a-symbol? (complement symbol?)]
                   (map not-a-symbol? [:a 'b "c"])))
 
-  "Praise and 'complement' may help you separate the wheat from the chaff"
+  ; "Praise and 'complement' may help you separate the wheat from the chaff"
   (= [:wheat "wheat" 'wheat]
        (let [not-nil? ___]
          (filter not-nil? [nil :wheat nil "wheat" nil 'wheat nil])))
 
-  "Partial functions allow procrastination"
+  ; "Partial functions allow procrastination"
   (= 20 (let [multiply-by-5 (partial * 5)]
           (___ __)))
 
-  "Don't forget: first things first"
+  ; "Don't forget: first things first"
   (= [__ __ __ __]
        (let [ab-adder (partial concat [:a :b])]
          (ab-adder [__ __])))
 
-  "Functions can join forces as one 'composed' function"
+  ; "Functions can join forces as one 'composed' function"
   (= 25 (let [inc-and-square (comp square inc)]
           (inc-and-square __)))
 
-  "Have a go on a double dec-er"
+  ; "Have a go on a double dec-er"
   (= __ (let [double-dec (comp dec dec)]
           (double-dec 10)))
 
-  "Be careful about the order in which you mix your functions"
+  ; "Be careful about the order in which you mix your functions"
   (= 99 (let [square-and-dec ___]
-          (square-and-dec 10))))
+          (square-and-dec 10)))
diff --git a/14_recursion.clj b/14_recursion.clj
index 4c39666..f71a408 100644
--- a/14_recursion.clj
+++ b/14_recursion.clj
@@ -1,54 +1,50 @@
-(ns koans.14-recursion
-  (:require [koan-engine.core :refer :all]))
-
-(defn is-even? [n]
-  (if (= n 0)
-    __
-    (___ (is-even? (dec n)))))
-
-(defn is-even-bigint? [n]
-  (loop [n   n
-         acc true]
+  (defn is-even? [n]
     (if (= n 0)
       __
-      (recur (dec n) (not acc)))))
+      (___ (is-even? (dec n)))))
 
-(defn recursive-reverse [coll]
-  __)
+  (defn is-even-bigint? [n]
+    (loop [n   n
+           acc true]
+      (if (= n 0)
+        __
+        (recur (dec n) (not acc)))))
 
-(defn factorial [n]
-  __)
+  (defn recursive-reverse [coll]
+    __)
 
-(meditations
-  "Recursion ends with a base case"
+  (defn factorial [n]
+    __)
+
+  ; "Recursion ends with a base case"
   (= true (is-even? 0))
 
-  "And starts by moving toward that base case"
+  ; "And starts by moving toward that base case"
   (= false (is-even? 1))
 
-  "Having too many stack frames requires explicit tail calls with recur"
+  ; "Having too many stack frames requires explicit tail calls with recur"
   (= false (is-even-bigint? 100003N))
 
-  "Reversing directions is easy when you have not gone far"
+  ; "Reversing directions is easy when you have not gone far"
   (= '(1) (recursive-reverse [1]))
 
-  "Yet it becomes more difficult the more steps you take"
+  ; "Yet it becomes more difficult the more steps you take"
   (= '(5 4 3 2 1) (recursive-reverse [1 2 3 4 5]))
 
-  "Simple things may appear simple."
+  ; "Simple things may appear simple."
   (= 1 (factorial 1))
 
-  "They may require other simple steps."
+  ; "They may require other simple steps."
   (= 2 (factorial 2))
 
-  "Sometimes a slightly bigger step is necessary"
+  ; "Sometimes a slightly bigger step is necessary"
   (= 6 (factorial 3))
 
-  "And eventually you must think harder"
+  ; "And eventually you must think harder"
   (= 24 (factorial 4))
 
-  "You can even deal with very large numbers"
+  ; "You can even deal with very large numbers"
   (< 1000000000000000000000000N (factorial 1000N))
 
-  "But what happens when the machine limits you?"
-  (< 1000000000000000000000000N (factorial 100003N)))
+  ; "But what happens when the machine limits you?"
+  (< 1000000000000000000000000N (factorial 100003N))
diff --git a/15_destructuring.clj b/15_destructuring.clj
index 32fc983..39c7caf 100644
--- a/15_destructuring.clj
+++ b/15_destructuring.clj
@@ -1,44 +1,36 @@
-(ns koans.15-destructuring
-  (:require [koan-engine.core :refer :all]))
 
-(def test-address
-  {:street-address "123 Test Lane"
-   :city "Testerville"
-   :state "TX"})
-
-(meditations
-  "Destructuring is an arbiter: it breaks up arguments"
+  ; "Destructuring is an arbiter: it breaks up arguments"
   (= __ ((fn [[a b]] (str b a))
          [:foo :bar]))
 
-  "Whether in function definitions"
+  ; "Whether in function definitions"
   (= (str "An Oxford comma list of apples, "
           "oranges, "
           "and pears.")
      ((fn [[a b c]] __)
       ["apples" "oranges" "pears"]))
 
-  "Or in let expressions"
+  ; "Or in let expressions"
   (= "Rich Hickey aka The Clojurer aka Go Time aka Lambda Guru"
      (let [[first-name last-name & aliases]
            (list "Rich" "Hickey" "The Clojurer" "Go Time" "Lambda Guru")]
        __))
 
-  "You can regain the full argument if you like arguing"
+  ; "You can regain the full argument if you like arguing"
   (= {:original-parts ["Stephen" "Hawking"] :named-parts {:first "Stephen" :last "Hawking"}}
      (let [[first-name last-name :as full-name] ["Stephen" "Hawking"]]
        __))
 
-  "Break up maps by key"
+  ; "Break up maps by key"
   (= "123 Test Lane, Testerville, TX"
      (let [{street-address :street-address, city :city, state :state} test-address]
        __))
 
-  "Or more succinctly"
+  ; "Or more succinctly"
   (= "123 Test Lane, Testerville, TX"
      (let [{:keys [street-address __ __]} test-address]
        __))
 
-  "All together now!"
+  ; "All together now!"
   (= "Test Testerson, 123 Test Lane, Testerville, TX"
-     (___ ["Test" "Testerson"] test-address)))
+     (___ ["Test" "Testerson"] test-address))
diff --git a/16_refs.clj b/16_refs.clj
index 3395f29..ee7d551 100644
--- a/16_refs.clj
+++ b/16_refs.clj
@@ -1,22 +1,16 @@
-(ns koans.16-refs
-  (:require [koan-engine.core :refer :all]))
 
-(def the-world (ref "hello"))
-(def bizarro-world (ref {}))
-
-(meditations
-  "In the beginning, there was a word"
+  ; "In the beginning, there was a word"
   (= __ (deref the-world))
 
-  "You can get the word more succinctly, but it's the same"
+  ; "You can get the word more succinctly, but it's the same"
   (= __ @the-world)
 
-  "You can be the change you wish to see in the world."
+  ; "You can be the change you wish to see in the world."
   (= __ (do
           (dosync (ref-set the-world "better"))
           @the-world))
 
-  "Alter where you need not replace"
+  ; "Alter where you need not replace"
   (= __ (let [exclamator (fn [x] (str x "!"))]
           (dosync
            (alter the-world exclamator)
@@ -24,19 +18,19 @@
            (alter the-world exclamator))
           @the-world))
 
-  "Don't forget to do your work in a transaction!"
+  ; "Don't forget to do your work in a transaction!"
   (= 0 (do __
            @the-world))
 
-  "Functions passed to alter may depend on the data in the ref"
+  ; "Functions passed to alter may depend on the data in the ref"
   (= 20 (do
           (dosync (alter the-world ___))))
 
-  "Two worlds are better than one"
+  ; "Two worlds are better than one"
   (= ["Real Jerry" "Bizarro Jerry"]
        (do
          (dosync
           (ref-set the-world {})
           (alter the-world assoc :jerry "Real Jerry")
           (alter bizarro-world assoc :jerry "Bizarro Jerry")
-          __))))
+          __)))
diff --git a/17_atoms.clj b/17_atoms.clj
index 17d92dd..f5ca9f3 100644
--- a/17_atoms.clj
+++ b/17_atoms.clj
@@ -1,33 +1,28 @@
-(ns koans.17-atoms
-  (:require [koan-engine.core :refer :all]))
 
-(def atomic-clock (atom 0))
-
-(meditations
-  "Atoms are like refs"
+  ; "Atoms are like refs"
   (= __ @atomic-clock)
 
-  "You can change at the swap meet"
+  ; "You can change at the swap meet"
   (= __ (do
           (swap! atomic-clock inc)
           @atomic-clock))
 
-  "Keep taxes out of this: swapping requires no transaction"
+  ; "Keep taxes out of this: swapping requires no transaction"
   (= 5 (do
          __
          @atomic-clock))
 
-  "Any number of arguments might happen during a swap"
+  ; "Any number of arguments might happen during a swap"
   (= __ (do
           (swap! atomic-clock + 1 2 3 4 5)
           @atomic-clock))
 
-  "Atomic atoms are atomic"
+  ; "Atomic atoms are atomic"
   (= __ (do
           (compare-and-set! atomic-clock 100 :fin)
           @atomic-clock))
 
-  "When your expectations are aligned with reality, things proceed that way"
+  ; "When your expectations are aligned with reality, things proceed that way"
   (= :fin (do
             (compare-and-set! __ __ __)
-            @atomic-clock)))
+            @atomic-clock))
diff --git a/18_macros.clj b/18_macros.clj
index 931dc75..223de8d 100644
--- a/18_macros.clj
+++ b/18_macros.clj
@@ -1,5 +1,3 @@
-(ns koans.18-macros
-  (:require [koan-engine.core :refer :all]))
 
 (defmacro hello [x]
   (str "Hello, " x))
@@ -25,21 +23,20 @@
             (r-infix ~first-arg)
             (r-infix ~others)))))
 
-(meditations
-  "Macros are like functions created at compile time"
+  ; "Macros are like functions created at compile time"
   (= __ (hello "Macros!"))
 
-  "I can haz infix?"
+  ; "I can haz infix?"
   (= __ (infix (9 + 1)))
 
-  "Remember, these are nothing but code transformations"
+  ; "Remember, these are nothing but code transformations"
   (= __ (macroexpand '(infix (9 + 1))))
 
-  "You can do better than that - hand crafting FTW!"
+  ; "You can do better than that - hand crafting FTW!"
   (= __ (macroexpand '(infix-better (10 * 2))))
 
-  "Things don't always work as you would like them to... "
+  ; "Things don't always work as you would like them to... "
   (= __ (macroexpand '(infix-better ( 10 + (2 * 3)))))
 
-  "Really, you don't understand recursion until you understand recursion"
-  (= 36 (r-infix (10 + (2 * 3) + (4 * 5)))))
+  ; "Really, you don't understand recursion until you understand recursion"
+  (= 36 (r-infix (10 + (2 * 3) + (4 * 5))))
diff --git a/19_datatypes.clj b/19_datatypes.clj
index d6eb31f..209d3a6 100644
--- a/19_datatypes.clj
+++ b/19_datatypes.clj
@@ -1,47 +1,25 @@
-(ns koans.19-datatypes
-  (:require [koan-engine.core :refer :all]))
 
-(defrecord Nobel [prize])
-(deftype Pulitzer [prize])
-
-(defprotocol Award
-  (present [this recipient]))
-
-(defrecord Oscar [category]
-  Award
-  (present [this recipient]
-    (print (str "Congratulations on your "
-                (:category this) " Oscar, "
-                recipient
-                "!"))))
-
-(deftype Razzie [category]
-  Award
-  (present [this recipient]
-    __))
-
-(meditations
-  "Holding records is meaningful only when the record is worthy of you"
+  ; "Holding records is meaningful only when the record is worthy of you"
   (= __ (.prize (Nobel. "peace")))
 
-  "Types are quite similar"
+  ; "Types are quite similar"
   (= __ (.prize (Pulitzer. "literature")))
 
-  "Records may be treated like maps"
+  ; "Records may be treated like maps"
   (= __ (:prize (Nobel. "physics")))
 
-  "While types may not"
+  ; "While types may not"
   (= __ (:prize (Pulitzer. "poetry")))
 
-  "Further study reveals why"
+  ; "Further study reveals why"
   (= __
      (map map? [(Nobel. "chemistry")
                 (Pulitzer. "music")]))
 
-  "Either sort of datatype can define methods in a protocol"
+  ; "Either sort of datatype can define methods in a protocol"
   (= __
      (with-out-str (present (Oscar. "Best Picture") "Evil Alien Conquerors")))
 
-  "Surely we can implement our own by now"
+  ; "Surely we can implement our own by now"
   (= "You're really the Worst Picture, Final Destination 5... sorry."
-     (with-out-str (present (Razzie. "Worst Picture") "Final Destination 5"))))
+     (with-out-str (present (Razzie. "Worst Picture") "Final Destination 5")))
diff --git a/20_java_interop.clj b/20_java_interop.clj
index 8a7a6e2..6a13d66 100644
--- a/20_java_interop.clj
+++ b/20_java_interop.clj
@@ -1,19 +1,16 @@
-(ns koans.20-java-interop
-  (:require [koan-engine.core :refer :all]))
 
-(meditations
-  "You may have done more with Java than you know"
+  ; "You may have done more with Java than you know"
   (= __ (class "warfare")) ; hint: try typing (javadoc "warfare") in the REPL
 
-  "The dot signifies easy and direct Java interoperation"
+  ; "The dot signifies easy and direct Java interoperation"
   (= __ (.toUpperCase "select * from"))
 
-  "But instance method calls are very different from normal functions"
+  ; "But instance method calls are very different from normal functions"
   (= ["SELECT" "FROM" "WHERE"] (map ___ ["select" "from" "where"]))
 
-  "Constructing might be harder than breaking"
+  ; "Constructing might be harder than breaking"
   (= 10 (let [latch (java.util.concurrent.CountDownLatch. __)]
           (.getCount latch)))
 
-  "Static methods are slashing prices!"
-  (== __ (Math/pow 2 10)))
+  ; "Static methods are slashing prices!"
+  (== __ (Math/pow 2 10))
diff --git a/21_partition.clj b/21_partition.clj
index 821ef09..f4790b7 100644
--- a/21_partition.clj
+++ b/21_partition.clj
@@ -1,21 +1,18 @@
-(ns koans.21-partition
-  (:require [koan-engine.core :refer :all]))
 
-(meditations
-  "To split a collection you can use the partition function"
+  ; "To split a collection you can use the partition function"
   (= '((0 1) (2 3)) (__ 2 (range 4)))
 
-  "But watch out if there are not enough elements to form n sequences"
+  ; "But watch out if there are not enough elements to form n sequences"
   (= '(__) (partition 3 [:a :b :c :d :e]))
 
-  "You can use partition-all to include any leftovers too"
+  ; "You can use partition-all to include any leftovers too"
   (= __ (partition-all 3 (range 5)))
 
-  "If you need to, you can start each sequence with an offset"
+  ; "If you need to, you can start each sequence with an offset"
   (= '((0 1 2) (5 6 7) (10 11 12)) (partition 3 __ (range 13)))
 
-  "Consider padding the last sequence with some default values..."
+  ; "Consider padding the last sequence with some default values..."
   (= '((0 1 2) (3 4 5) (6 :hello)) (partition 3 3 [__] (range 7)))
 
-  "... but notice that they will only pad up to the given sequence length"
-  (= '((0 1 2) (3 4 5) __) (partition 3 3 [:these :are "my" "words"] (range 7))))
+  ; "... but notice that they will only pad up to the given sequence length"
+  (= '((0 1 2) (3 4 5) __) (partition 3 3 [:these :are "my" "words"] (range 7)))
diff --git a/22_group_by.clj b/22_group_by.clj
index 01de423..8921031 100644
--- a/22_group_by.clj
+++ b/22_group_by.clj
@@ -1,26 +1,19 @@
-(ns koans.22-group-by
-  (:require [koan-engine.core :refer :all]))
 
-(defn get-odds-and-evens [coll]
-  (let [{odds true evens false} (group-by __ coll)]
-    [odds evens]))
-
-(meditations
-  "To categorize a collection by some function, use group-by."
+  ; "To categorize a collection by some function, use group-by."
   (= __ (group-by count ["hello" "world" "foo" "bar"]))
 
-  "You can simulate filter + remove in one pass"
+  ; "You can simulate filter + remove in one pass"
   (= (get-odds-and-evens [1 2 3 4 5])
      ((juxt filter remove) odd? [1 2 3 4 5])
      [[1 3 5] [2 4]])
 
-  "You can also group by a primary key"
+  ; "You can also group by a primary key"
   (= __
      (group-by :id [{:id 1 :name "Bob"}
                     {:id 2 :name "Jennifer"}
                     {:id 1 :last-name "Smith"} ]))
 
-  "But be careful when you group by a non-required key"
+  ; "But be careful when you group by a non-required key"
   (= {"Bob" [{:name "Bob" :id 1}]
       "Jennifer" [{:name "Jennifer" :id 2}]
       __ [{:last-name "Smith" :id 1}]}
@@ -28,9 +21,9 @@
                     {:id 2 :name "Jennifer"}
                     {:id 1 :last-name "Smith"}]))
 
-  "The true power of group-by comes with custom functions"
+  ; "The true power of group-by comes with custom functions"
   (= __
      (group-by #(if (:bad %) :naughty-list :nice-list)
                [{:name "Jimmy" :bad true}
                 {:name "Jane" :bad false}
-                {:name "Joe" :bad true}])))
+                {:name "Joe" :bad true}]))
diff --git a/23_meta.clj b/23_meta.clj
index df0274a..8041ead 100644
--- a/23_meta.clj
+++ b/23_meta.clj
@@ -1,18 +1,11 @@
-(ns koans.23-meta
-  (:require [koan-engine.core :refer :all]))
 
-(def giants
-  (with-meta 'Giants
-    {:league "National League"}))
-
-(meditations
-  "Some objects can be tagged using the with-meta function"
+  ; "Some objects can be tagged using the with-meta function"
   (= __ (meta giants))
 
-  "Or more succinctly with a reader macro"
+  ; "Or more succinctly with a reader macro"
   (= __ (meta '^{:division "West"} Giants))
 
-  "While others can't"
+  ; "While others can't"
   (= __ (try
           (with-meta
             2
@@ -20,18 +13,18 @@
           (catch ClassCastException e
             "This doesn't implement the IObj interface")))
 
-  "Notice when metadata carries over"
+  ; "Notice when metadata carries over"
   (= __ (meta (merge '^{:foo :bar} {:a 1 :b 2}
                      {:b 3 :c 4})))
 
-  "And when it doesn't"
+  ; "And when it doesn't"
   (= __ (meta (merge {:a 1 :b 2}
                      '^{:foo :bar} {:b 3 :c 4})))
 
-  "Metadata can be used as a type hint to avoid reflection during runtime"
+  ; "Metadata can be used as a type hint to avoid reflection during runtime"
   (= __ (#(.charAt ^String % 0) "Cast me"))
 
-  "You can directly update an object's metadata"
+  ; "You can directly update an object's metadata"
   (= 8 (let [giants
              (with-meta
                'Giants
@@ -39,13 +32,13 @@
          (swap! (:world-series-titles (meta giants)) __)
          @(:world-series-titles (meta giants))))
 
-  "You can also create a new object from another object with metadata"
+  ; "You can also create a new object from another object with metadata"
   (= {:league "National League" :park "AT&T Park"}
      (meta (vary-meta giants
                       assoc __ __)))
 
-  "But it won't affect behavior like equality"
+  ; "But it won't affect behavior like equality"
   (= __ (vary-meta giants dissoc :league))
 
-  "Or the object's printed representation"
-  (= __ (pr-str (vary-meta giants dissoc :league))))
+  ; "Or the object's printed representation"
+  (= __ (pr-str (vary-meta giants dissoc :league)))