diff --git a/collects/scribblings/gui/editor-intf.scrbl b/collects/scribblings/gui/editor-intf.scrbl
index 4555fda0fd..7f16be314f 100644
--- a/collects/scribblings/gui/editor-intf.scrbl
+++ b/collects/scribblings/gui/editor-intf.scrbl
@@ -1,5 +1,9 @@
 #lang scribble/doc
-@(require "common.rkt")
+@(require "common.rkt"
+          scribble/eval)
+
+@(define editor-eval (make-base-eval))
+@(editor-eval '(require racket/class))
 
 @definterface/title[editor<%> ()]{
 
@@ -206,7 +210,52 @@ See also @method[editor<%> refresh-delayed?] and @method[editor<%>
 
 If the @racket[undoable?] flag is @racket[#f], then the changes made
  in the sequence cannot be reversed through the @method[editor<%>
- undo] method. This flag is only effective for the outermost
+ undo] method. To accomplish this, the editor just does not add
+ entries to the undo log when in an edit sequence where the
+ @racket[undoable?] flag is @racket[#f]. So, for example, if an
+ @litchar{a} is inserted into the editor and then a @litchar{b}
+ is inserted, and then an un-undoable edit-sequence begins,
+ and the @litchar{a} is colored red, and then the edit-sequence ends,
+ then an undo will remove the @litchar{b}, leaving the @litchar{a}
+ colored red.
+ 
+ This behavior also means that editors can get confused. Consider
+ this program:
+ @examples[#:eval 
+           editor-eval
+           (eval:alts (define t (new text%))
+                      ;; this is a pretty horrible hack, but 
+                      ;; the sequence of calls below behaves 
+                      ;; the way they are predicted to as of
+                      ;; the moment of this commit
+                      (define t 
+                        (new (class object%
+                               (define/public (set-max-undo-history x) (void))
+                               (define/public (insert . args) (void))
+                               (define/public (begin-edit-sequence a b) (void))
+                               (define/public (end-edit-sequence) (void))
+                               (define/public (undo) (void))
+                               (define first? #t)
+                               (define/public (get-text)
+                                 (cond
+                                   [first?
+                                    (set! first? #f)
+                                    "cab"]
+                                   [else "cb"]))
+                               (super-new)))))
+           (send t set-max-undo-history 'forever)
+           (send t insert "a")
+           (send t insert "b")
+           (send t begin-edit-sequence #f #f)
+           (send t insert "c" 0 0)
+           (send t end-edit-sequence)
+           (send t get-text)
+           (send t undo)
+           (send t get-text)]
+ You might hope that the undo would remove the @litchar{b}, but it removes
+ the @litchar{a}.
+      
+ The @racket[undoable?] flag is only effective for the outermost
  @method[editor<%> begin-edit-sequence] when nested sequences are
  used. Note that, for a @racket[text%] object, the character-inserting
  version of @method[text% insert] interferes with sequence-based undo