> restart;
Load the standard basis.
> M[1] := <<1|0|0>,<0|-1|0>,<0|0|0>>:
> M[2] := <<0|0|0>,<0|1|0>,<0|0|-1>>:
> M[3] := <<0|1|0>,<0|0|0>,<0|0|0>>:
> M[4] := <<0|0|1>,<0|0|0>,<0|0|0>>:
> M[5] := <<0|0|0>,<1|0|0>,<0|0|0>>:
> M[6] := <<0|0|0>,<0|0|1>,<0|0|0>>:
> M[7] := <<0|0|0>,<0|0|0>,<1|0|0>>:
> M[8] := <<0|0|0>,<0|0|0>,<0|1|0>>:
Now, we wish to figure out how many times M[a] appears when we write M[k].M[i]-M[i].M[k] in terms of the standard basis. I couldn't come up with a quick solution so here  is the hack. What we do is notice that if we could see the matrix, then we know that the (i,j) component is 'always' the number of times M[a] appears in the representation in the standard matrix. The exception is with the terms on the diagonal. The upper right corner is correct for 3 by 3 matrices but the lower right corner is the negation of what it needs to be. Notice that this won't extend immediately to higher dimensions but the fix is very easy should one be ambitious enough. By example, suppose that the matrix we got after this multiplication was
[1 0 3]
[0 -2 0]
[0 0 1]
Then, in the standard representation, we have one M[1] term (the top right entry), three M[4] terms (the top right entry) and negative one M[2] terms (the bottom right entry). All this code does is extract that information and puts it into one big matrix. Perhaps there was a better way of setting up the indices but I'll leave that to the interested reader.
> c[1]:= 1: c[2] := 3: c[3] := 1: c[4]:= 1: c[5] := 2: c[6] := 2: c[7]:= 3: c[8] := 3:  
> d[1] := 1: d[2]:= 3: d[3] := 2: d[4] := 3: d[5]:= 1: d[6] := 3: d[7] := 1: d[8]:= 2: 
> cor[1] := 1:  cor[2] := -1: cor[3] := 1: cor[4] := 1: cor[5] := 1: cor[6] := 1: cor[7] := 1: cor[8] := 1:
> with(LinearAlgebra):
> for k from 1 by 1 while k <= 8 do 
> A[k] := Matrix(8):
> for i from 1 by 1 while i <= 8 do for j from 1 by 1 while j <= 8 do 
>       A[k](j,i) := cor[j]*(M[k].M[i]-M[i].M[k])(c[j],d[j]):
> end do: end do: end do:
Now, compute the Killing Form and its determinant
> B := Matrix(8):
> for i from 1 by 1 while i <= 8 do  for j from 1 by 1 while j <= 8 do 
>     B(i,j) := Trace(A[i].A[j]):
> end do: end do:
> B;
> Determinant(B);
> ifactor(Determinant(B));

               [12    -6    0    0    0    0    0    0]
               [                                      ]
               [-6    12    0    0    0    0    0    0]
               [                                      ]
               [ 0     0    0    0    6    0    0    0]
               [                                      ]
               [ 0     0    0    0    0    0    6    0]
               [                                      ]
               [ 0     0    6    0    0    0    0    0]
               [                                      ]
               [ 0     0    0    0    0    0    0    6]
               [                                      ]
               [ 0     0    0    6    0    0    0    0]
               [                                      ]
               [ 0     0    0    0    0    6    0    0]


                               -5038848


                                  8     9
                             - (2)   (3)

Notice that this matrix is nothing more than 2nTr(M[i].M[j]). Wish I knew of this earlier!