Doing beta reduction while constructing the boolean expression in lambda calculus
It is helpful to look at $\lambda$ abstractions as functions, e.g. $T \equiv \lambda x y. x$ "is" a function that takes $2$ variables as arguments ($x,y$; those between "$\lambda$" and ".") and returns the first of them - $x$ (expression after the "."). On the other hand, we define $F$ to also take $2$ arguments and return the second one - $y$.

In this sense, $\beta$-reduction is a process of evaluating a function at given values (the ones that abstraction is applied to). One should be careful about $\alpha$-renaming and have in mind currying, but we will not go into that here.

Let's now define the $AND$ operator.

What does it take as arguments?
We can also think of it as a function, and therefore it must take $2$ arguments (truth values), so we would define it something like 
\begin{equation}
AND := \lambda a b.\ &lt;body,\ i.e. what\ it\ returns&gt;.
\end{equation}

What does it need to return?
If it receives $T$ and $T$ for it's arguments, it must return $T$. Otherwise, it returns $F$.

Constructing the body.
Having in mind that $a$ and $b$ will be substituted with $T$ or $F$, we can use them in the body of $AND$. We will use their property of returning the first or second argument. Consider the following definition;
\begin{equation}
AND := \lambda a b.\ a\ b\ F
\end{equation}
Upon receiving its arguments $a$ and $b$, operator $AND$ is returning the application of its first argument (and we know it will be a "function" of $2$ arguments that returns either its first or the second argument) onto its second argument and $F$. Therefore, if the first argument ($a$) happens to be $T$, we return the second argument ($b$) as a solution (in other words, the result of $AND\ T\ b$ is $b$). If the first argument ($a$) happens to be $F$, we return $F$.

Cases. There are $4$ cases that can happen.


$AND\ F\ F$. This will evaluate as follows:
\begin{equation}
(\lambda a b.\ a\ b\ F)\ F\ F = F\ F\ F = (\lambda x y.\ y)\ F\ F = F 
\end{equation}
$AND\ F\ T$. This will evaluate as follows:
\begin{equation}
(\lambda a b.\ a\ b\ F)\ F\ T = F\ T\ F = (\lambda x y.\ y)\ T\ F = F 
\end{equation}
$AND\ T\ F$. This will evaluate as follows:
\begin{equation}
(\lambda a b.\ a\ b\ F)\ T\ F = T\ F\ F = (\lambda x y.\ x)\ F\ F = F 
\end{equation}
$AND\ T\ T$. This will evaluate as follows:
\begin{equation}
(\lambda a b.\ a\ b\ F)\ T\ T = T\ T\ F = (\lambda x y.\ x)\ T\ F = T 
\end{equation}


This is a somewhat friendly $\lambda$-calculus workflow I presented here, but I think it is the right approach for someone who is starting to learn about it and needs some intuitive notes on its nature. 

For further research, following links should be useful as a starting point;


definitions of logical operators: https://en.wikipedia.org/wiki/Church_encoding#Church_Booleans
$\lambda$-calculus interpreter to try out your ideas and see reduction steps; http://jacksongl.github.io/files/demo/lambda/index.htm