diff --git a/src/lisp/lisp-notes.org b/src/lisp/lisp-notes.org
index 614ac8f..c4a7be2 100644
--- a/src/lisp/lisp-notes.org
+++ b/src/lisp/lisp-notes.org
@@ -13,24 +13,13 @@
 
   An example assembly is in =scratch.s=.
 
-** First Pass
+  Values will be encoded as double words, where the lowest few bits
+  indicate the type.
 
-   The first pass will involve finding all the local variables
-   (i.e. anything defined with =let=) and all the temporary values
-   necessary. Once a variable is out of scope, its stack space becomes
-   usable by other variables. Similarly, once a temporary is used, its
-   space becomes available. Variables are addressable by name but
-   temporaries are not.
+** Closures and lambdas
 
-** Second Pass
-
-   The second pass will actually generate assembly. First enough space
-   will be reserved on the stack for the variables and temporaries,
-   then the AST will be walked as before to generate all the
-   appropriate function calls.
-
-   When a function call is generated, first temporaries are allocated
-   for all its arguments. Then the sub-expressions are compiled left to
-   right given these temporary locations as the outputs. For now we
-   will assume that everything is either a variable or a function
-   call, there will be no literals yet.
+   Closures will have to be done in two passes, one pass to find the
+   free variables and one to generate the code. Free variables will be
+   accessed as an offset to =edi=, which will point to the location of
+   the lambda on the heap. =[edi]= will evaluate to the address of the
+   lambda, =[edi + 1]= for the first free variable, etc.