What did you learn in your PhD that changed your mind?
Arc tries very hard to be a minimal language. This is good for the implementation (which is short, and therefore easy to read and hack). It was also an expression of pg's thinking about language power, which if I recall he defined as how concise programs in the language can be. The intuition being that a minimal language would naturally be powerful because finding the smallest set of primitives to define the language itself forces them to be orthogonal and expressive enough that you can build anything else on top of that. But I'm not sure this is true; instead I think what actually seems to have happened with Arc is that pg retreaded much of the same ground that Lisp had already covered, just with shorter names and some minor syntax sugar. In short, for a PL PhD, not very interesting.
In general I'd say during my PhD I learned that there's a non-trivial tradeoff between minimality, expressiveness, and static analysis (which is related to both safety (via type systems) and performance (via compiler optimizations)). The static analysis problem for nearly any non-trivial property is very hard in most general purpose languages. In fact it's so hard that we've basically given up trying to do aggressive static analyses (for things like whole-program parallel and distributed code generation). And yet, if you're willing to introduce non-minimal features, it turns out that some of these problems are actually tractable. Here are some examples of the sort of thing I'm talking about from my own work: [0][1][2][3].
I'd also add that some of the things I thought were great about Lisps have actually been replicated in more syntax-ful languages (e.g., Terra [4] has metaprogramming with very similar power to Lisp, and also many advantages I haven't seen in any Lisp implementation). And meanwhile, some things that Lisps have traditionally included, like a self-contained, owns-the-world, garbage collected implementation, aren't necessarily all they're cracked up to be, as we've seen with e.g., Rust's approach to safety and performance without a GC. So in general, I think we've seen a lot of interesting developments in the PL world in the last 10-ish years, and most of them have not come from the Lisp community.
[0]: https://legion.stanford.edu/pdfs/dpl2016.pdf
[1]: https://legion.stanford.edu/pdfs/cr2017.pdf
[2]: https://legion.stanford.edu/pdfs/parallelizer2019.pdf