Self-enumerating pangrams
Python 2, 615 bytes



def g(n):S=str.split;D=S('z one two three four five six seven eight nine');K=' fif six seven eigh nine';n,m=n/100,n%100;e,d=m/10,m%10;return' '.join([D[n],'hundred']*(n&gt;0)+([S('ten eleven twelve thir four'+K)[d]+'teen'*(d&gt;2)]if 9&lt;m&lt;20else[S('twen thir for'+K)[e-2]+'ty']*(e&gt;0)+[D[d]]*(d&gt;0)))
from random import*
X='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def f(p):
 T=set();s='';i=0
 while 1:
&#9;Q=s.upper().count;t=p+' '+', '.join(['&amp; '*(c=='Z')+g(Q(c))+' '+c+'s'*(Q(c)!=1)for c in X])+'.'
        if s==t:return i,t
&#9;if t in T:t=''.join(c*max(1,t.upper().count(c)+(randint(0,6)-3)*(random()&lt;0.25))for c in X)
&#9;T.add(t);s=t;i+=1


Try it online!

The function f takes p as the string prefix; and returns a tuple of an integer representing the number of steps taken, and the autogram.

The function g encodes a number 1&lt;=n&lt;=999 to its english string; it takes up 291 bytes, roughly half the total byte count. The code

Q=s.upper().count
t=p+' '+', '.join(['&amp; '*(c=='Z')+g(Q(c))+' '+c+'s'*(Q(c)!=1)for c in X])+'.'


encodes the string s into a (potentially autogram-matic) pangram t. 

We loop over the process, hoping for the situation where we find a t such that t is an autogram (i.e., where t==s). If When we get into a loop, we randomly nudge the counts of letters in a completely ad hoc manner.

For most values of p, this process will time out on TIO. Typically, millions of possibilities are examined before finding a 'winning' combination.

I don't have any proof at all, but my guess is: (a) apart from an exhaustive brute force search similar to what the originator Lee Sallows describes here and implements in hardware (!), this sort of random heuristic is about as good as you can get; and (b) there will be no solutions for many (most?) initial phrases p.