Generating and using a list of prime numbers
for one thing, (eq nil p) is usually written (not p). 

the variable p participating only in that do should be declared inside it, not outside it in the enclosing let. Everything should be in its proper place. Same with result - make do your last form and use the return clause of do to return the result:

(defun plist (n)
  (let (
        (arr (make-array (+ n 1) :element-type 'boolean :initial-element t))
       )
    (setf (aref arr 0) nil)
    (setf (aref arr 1) nil)

    (do ( (p 3) 
          (result (list 2))) 
        ( (not p)  (nreverse result))

      (push p result)   ; and what if n==2 ??
      ....
      )))


Don't mix arefs and svrefs, be consistent. Again, the test (when (eq t (svref arr i)) ...) would normally be written just as (when (svref arr i) ...).

Your do loop is a little buggy: it adds 3 unconditionally, even if n &lt; 3. Reorganize. Or, and since you don't inspect them, no need to mark 0 and 1 as non-primes, just like we don't bother with the evens. Which means we get to declare the array inside the do's scope too:

(defun plist (n)
  (do ((arr (make-array (+ n 1) :element-type 'boolean :initial-element t))
       (result (list 2))
       (p      3        (+ p 2))) 
      ((&gt; p n)
       (nreverse result))       ; return form
    (when (aref arr p)
        (push p result)
        (if (&lt;= p (/ n p))   
          (loop for i from (* p p) to n by (* 2 p)
            do (setf (aref arr i) nil))))))


An algorithmic improvement, though you didn't want one: start eliminating multiples of p from (* p p), not from (+ p p), and increment by steps of (* 2 p) among odds only, for twice the speed. 

Now that the code is short and compact, we see one more possibility for improvement: if we hit the termination condition, no need to recheck it. Finally, add the documentation string there too:

(defun plist (n)
  "return the list of primes not greater than n. 
   build it by means of the sieve of Eratosthenes."
  (do ((arr (make-array (+ n 1) :element-type 'boolean :initial-element t))
       (result (list 2))
       (p      3        (+ p 2)))   ; a candidate possible prime
      ((&gt; p (/ n p))
       (nconc (nreverse result)
              (loop for i from p to n by 2 if (aref arr i) collect i)))
    (when (aref arr p)              ; not marked as composite: p is prime
        (push p result)  
        (loop for i from (* p p) to n by (* 2 p)  ; mark the multiples
            do (setf (aref arr i) nil)))))


I don't find micro-commenting adding much clarity (even the opposite), but YMMV. Variable names like arr and result are self-documenting.