It's the capability of a program to "reflect" upon itself, I.E. to inspect and understand its own code.
As an example, In C# you can write a class...
public class MyClass
{
public void MyMethod()
{
...
}
}
...and you can create an instance of it, and use it, like this...
var myClass = new MyClass();
myClass.MyMethod();
Simple enough, nothing we haven't all seen before.
But you can do the same thing with reflection, as such...
var type = System.Reflection.Assembly.GetExecutingAssembly()
.GetType("MyClass");
var constructor = type.GetConstructor(Array.Empty<Type>());
var instance = constructor.Invoke(Array.Empty<Object>());
var method = type.GetMethod("MyMethod");
var delegate = method.CreateDelegate(typeof(Action), instance);
delegate.DynamicInvoke(Array.Empty<object>());
Obnoxious and verbose and tossing basically all type safety out the window, but it does enable some pretty crazy interesting things. Like self-discovery and dynamic loading of plugins, or self-configuration of apps. Also often useful when messing with generics. I could dig up some practical use-cases, if you're curious.
I'm guessing Vance said something insulting about Appalachia.