So, Yahoo acquires Viaweb and rewrites it. The end result
  is inferior to the original Lisp-based product. Sony
  acquires Naughty Dog and decides to eliminate the
  Lisp-based development infrastructure. The end result is
  an inferior game development environment. Sure, there
  were probably a lot of reasons for these decisions by
  Yahoo and Sony (probably none of which had anything to do
  with productivity or technical excellence - large
  companies have other drivers which have more importance
  than these two); however, the end result for both
  companies has been something inferior to what they
  originally acquired.

Quoted from http://bc.tech.coop/blog/060118.html

Edit: The post has more about in what respect the author considers the replacements inferior.

This inferior game development environment led to two incredibly spectacular, well-rated games. In my opinion, Uncharted 1 and 2 completely eclipsed all of their previous work.

Andy Gavin, one of Naughty Dog's co-founders, posted on HN a few weeks back summarizing his work with Lisp (and GOAL) and how he's now moved to Ruby:

    From the late 80s through the early 2000s Lisp was my language of choice. 
    The post author went through many of its advantages -- mostly true. I even
    went so far as to write an entire compiler and environment (a 
    several man-year endeavor) to design two different runtime oriented
    dialects called GOOL and GOAL used in 8 Naughty Dog Crash Bandicoot
    and Jak & Daxter games. All 30-60 FPS action games -- 40 million copies
    sold. All written in Lisp! (more or less)

    Eventually, it was Ruby that got me off Lisp. It does most of what made 
    Lisp great, and the support factor is huge. There are clean standard 
    libraries for everything, the garbage collector is good (the one in ACL 
    is was so awful and dated -- I last used it in '07 -- you pretty
    much had to turn it off.

    I miss the S expressions and the macros. But you can do most macro like
    things with a good block expression in Ruby, and you can even do 
    auto-generated macro like functions with strings. It just isn't 
    as elegant as Lisp.

    The Ruby class system is a bit baroque, but it's actually 
    better in many ways than CLOS, which suffers from being too dated. 
    In Ruby you can do a lot of very cool things with extend and include. 
    It's just a slightly different way of thinking.

    The implementation isn't the fastest, but it's good. The Lisp 
    implementations were all clunky and felt like 80s codebases. 
    Oh wait, they are.

    Support. The rate of change in Ruby is 1000x that of Lisp. 
    Some new website has an API -- someone writes a Gem immediately.
    In Lisp you don't even have a really standard networking library!

(from http://news.ycombinator.com/item?id=1998321)

This reminds me of Peter Norvig's move to Python:

  I came to Python not because I thought it was a 
  better/acceptable/pragmatic Lisp, but because it was better 
  pseudocode. Several students claimed that they had a hard 
  time mapping from the pseudocode in my AI textbook to the 
  Lisp code that Russell and I had online. So I looked for 
  the language that was most like our pseudocode, and found 
  that Python was the best match. Then I had to teach myself 
  enough Python to implement the examples from the textbook. 
  I found that Python was very nice for certain types of 
  small problems, and had the libraries I needed to 
  integrate with lots of other stuff, at Google and 
  elsewhere on the net.

  I think Lisp still has an edge for larger projects and for 
  applications where the speed of the compiled code is 
  important. But Python has the edge (with a large number of 
  students) when the main goal is communication, not 
  programming per se.

  In terms of programming-in-the-large, at Google and 
  elsewhere, I think that language choice is not as 
  important as all the other choices: if you have the right 
  overall architecture, the right team of programmers, the 
  right development process that allows for rapid
  development with continuous improvement, then many 
  languages will work for you; if you don't have those 
  things you're in trouble regardless of your language choice.

(from http://news.ycombinator.com/item?id=1803815)