Validating an entity using a dynamic list of predicates
You can simplify your extension method a bit as so:

public static Boolean IsValidEntity&lt;T&gt;(this T entity, IEnumerable&lt;Predicate&lt;T&gt;&gt; predicates)
{
    return predicates.All(p =&gt; (bool)p.DynamicInvoke(entity));
}


This is a bit better for readability, and shouldn't have any cost in efficiency as LINQ short-circuits with All. I also switched your List for IEnumerable, just to save an unnecessary ToList call if you end up with some other kind of collection.

You should also check if you really need that DynamicInvoke. If not, you can further simplify to

public static Boolean IsValidEntity&lt;T&gt;(this T entity, IEnumerable&lt;Predicate&lt;T&gt;&gt; predicates)
{
    return predicates.All(p =&gt; p(entity));
}


Depending on your wider design, this might be enough. However, since you asked about extensibility, you can see that having to build predicates isn't the nicest business. For example, you had your 'less than 8' predicate. What if elsewhere in the code you wanted 'less than 7'? You'd have to repeat the (albeit very simple in this example) logic, just with a different number. 

If you tried to refactor this to adhere to the Don't Repeat Yourself principle, you might then end up with something like a PredicateFactory class which exists purely to build common predicates based on parameters. But this isn't fantastic design either. It would likely end up as a monolith of public methods without much cohesion, and violate the open/closed and single responsibility principle.

A better option might be to create an interface like:

interface IEntityValidator&lt;T&gt;
{
    bool IsValid(T Entity);
}


Instead of predicates, you can now create and use classes which implement this interface. This gives better adherence to the design principles I mentioned before, and allows you take full advantage of polymorphism (for more complicated validation you might find that inheritance is useful, for example). At this point your original method would be:

public static Boolean IsValidEntity&lt;T&gt;(this T entity, IEnumerable&lt;IEntityValidator&lt;T&gt;&gt; validators)
{
    return validators.All(v =&gt; v.IsValid(entity));
}


To my mind, that line is simple and readable enough that it may no longer warrant its own method, especially its own extension method which will apply to every single type. Validation doesn't seem like something that would be done in too many places, so even if you didn't like that line, you might just move it to a private method somewhere. That's more a matter of taste, though.