When I first saw a long-time Lisp programmer editing (and debugging)
his
code on Emacs it blowed my mind.   His code was flying.   Basically,
once you get used to, you won't work on (and think on) per-character
basis anymore.  Instead, you work on per-expression.   No matter how
complex the expression is, spanning many lines or nested so deeply,
you can treat the whole expression with a few keystrokes---e.g.
cutting an expr, skip next two exprs, paste the original expr, then
adjust the whole indentation; or sending a whole expression to
interactive
REPL and check the result; or factoring out a subexpression and turning
it into a local function.   You get a feeling you are grabbing the code
itself, not the characters on the screen.

For your original question: probably it's easier to appreciate what's
special in Scheme by shifting your viewpoint from a language user
to a language designer---the former is to accept the language features
as given and unchangeable, and tries to write all the solutions in it;
while
the latter first look at the problem, think about what language is
suitable
to describe the problem, then write the language using the base
language.

One example: Python got list comprehensions recently.  That's a cool
feature to have.  You can write code more in a way you couldn't before.
Somebody posted a code in Scheme that implements list comprehensions
essentially in several lines.   It's a joy to have that.  And it has
always been
possible; you don't need to wait for somebody to add the feature.