Understanding proof for Busy Beaver being uncomputable I found this proof on http://jeremykun.com/2012/02/08/busy-beavers-and-the-quest-for-big-numbers/ and have highlighted the part I don't understand in bold.

(BB(n) is defined as the number of steps made by n-state Busy Beavers.)


  Theorem: BB(n) is uncomputable. That is, there is no Turing machine
  that can take as input n and computes BB(n).
  
  
  
  Proof: Suppose to the contrary that such a machine existed, and call
  it T. We will use T to construct a machine which solves the halting
  problem as follows:
  
  On input &lt; T, w >, a description of a Turing
  machine and its associated input, we can determine in finite time the
  number of states that T has (it is encoded in the description of T).
  
  Now simply compute BB(n), where n is the number of states in T, and
  simulate T on input w, counting its steps as it proceeds.
  Eventually the simulation of T either halts, or makes more steps than BB(n). 
  
  In the former case, we may stop the computation and declare that T halts.
  In the latter, we know that BB(n) is the maximal number of steps that
  can occur for any Turing machine with n states that eventually halts.
  Therefore, if T had not halted on the input w, it must never halt.
  
  We may stop our computation there, proclaim an infinite loop, and thereby solve the halting problem.
  
  This is a contradiction, so the sequence BB(n) cannot be computable.


If we assume that T can calculate BB(n) for any n, don't we also have to assume that it does halt, and therefore that it will not exceed the steps of BB(n)? (That would also mean that using T to solve the halting problem does not work)
Just for the completeness, I will present my proof that shows uncomputability of BB function.
The structure of a correct proof would look something like the following.


Construct a universal Turing machine U that simulates any other Turing machines but writes ‘1’ on the output tape for every step of the simulation.
For any Turing machine M, there is an encoding 〈M〉for U. We create a new Turing machine by adding new states in U which first writes〈M〉on its input tape and runs it on U. Call this new Turing machine UM.
Let n be the number of states in UM, and m be the number of states in M. We can see that BB(n) upper-bounds the number of 1’s outputted by UM and also upper-bounds the maximal number of steps run by the halting Turing machine with m states. Hence, S(m) &lt;= BB(n), where S(m) is the maximal number of steps run by a halting Turing machine with m states. 
Given a Turing machine of size m, we can always determine corresponding value for n. 
If there is any function that always upper bounds S, it is uncomputable as it will contradict with the result from the halting problem. (Run a Turing machine that many steps to determine whether it halts or not)