> Lisp was never supposed to be written with S-expressions. They were intermediate representation, for bootstrapping.
That's not the complete picture.
The early Lisp manual had a definition for Lisp syntax. The Lisp syntax was based on M-expressions for code and S-expressions for data.
Basically what now is
(append (quote (1 2 3))
(quote (a b c)))
was
append[(1,2,3);(A,B,C)]
where the function call uses M-Expression syntax and the data were S-expressions.
Then we have so-called S-Functions, which work with S-expressions. append is such an s-function.
McCarthy then defined a mapping from M-Expressions to S-Expressions, thus that M-Expressions could be represented (not just written, but also in memory) as S-expressions.
In the next step he defined new S-functions called apply and eval, which took M-Expressions as S-Expression data and computed the results of apply or eval operations.
Example use of apply:
apply[(LAMBDA,(X,Y),(CONS,X,Y));((A,B),(B,C))]
Thus these s-functions could compute with code which was represented at runtime by s-expression data.
Thus such a program would use both code in M-Expression format and compute with code in S-Expression format.
Since these S-functions apply and eval could be themselves translated to s-expressions and get executed, the specific S-functions apply and eval could get executed by a s-expression evaluator.
The code above would then be written:
(APPLY,(LAMBDA,(X,Y),(CONS,X,Y)),(QUOTE,((A,B),(B,C))))
which in modern way would be written as
(apply (lambda (x y)
(cons x y))
(quote ((a b) (b c))))
Since programs thus were executed / computed as s-expressions, they were input, computed and printed as s-expressions.
Thus the idea of a simple s-expression meta-programming system made the idea of an additional step of m-expression syntax reading/printing less attractive.