Two players, Blake and Ruby, play the following game on an infinite grid of unit squares, all initially colored white. The players take turns starting with Blake. On Blake's turn, Blake selects one white unit square and colors it blue. On Ruby's turn, Ruby selects two white unit squares and colors them red. The players alternate until Blake decides to end the game. At this point, Blake gets a score, given by the number of unit squares in the largest (in terms of area) simple polygon containing only blue unit squares.
What is the largest score Blake can guarantee?
The answer is 4 squares.

Algorithm for Blake to obtain at least 4 squares. We simply let Blake start with any cell blue, then always draw adjacent to a previously drawn blue cell until this is no longer possible.

Note that for $n \leq 3$, any connected region of $n$ blue cells has more than $2 n$ liberties (non-blue cells adjacent to a blue cell); up to translation, rotation, and reflection, all the cases are shown in the figure below with liberties being denoted by circles.

So as long as $n \leq 3$, it's impossible that Ruby has blocked every liberty, since Ruby has colored exactly $2 n$ cells red. Therefore, this algorithm could only terminate once $n \geq 4$.

Algorithm for Ruby to prevent more than 4 squares. Divide the entire grid into $2 \times 2$ squares, which we call windows. Any time Blake makes a move in a cell $c$, let Ruby mark any orthogonal neighbors of $c$ in its window; then place any leftover red cells arbitrarily.
Claim - It's impossible for any window to contain two orthogonally adjacent blue cells.

Proof. By construction: if there were somehow two adjacent blue cells in the same window, whichever one was played first should have caused red cells to be added.

We show this gives the upper bound of 4 squares. Consider a blue cell $w$, and assume WLOG it is in the southeast corner of a window. Label squares $x, y, z$ as shown below.
Note that by construction, the blue polygon cannot leave the square $\{w, x, y, z\}$, since whenever one of these four cells is blue, its neighbours outside that square are guaranteed to be red. This implies the bound.
Remark (For Tetris fans). Here is a comedic alternative finish after proving the claim. Consider the possible tetrominoes (using the notation of https://en.wikipedia.org/wiki/ Tetromino\#One-sided_tetrominoes). We claim that only the square (0) is obtainable; as
- T, J/L, and I all have three cells in a row, so they can't occur;
- S and $\mathrm{Z}$ can't occur either; if the bottom row of an $\mathrm{S}$ crossed a window boundary, then the top row doesn't for example.
Moreover, the only way a blue 0 could be obtained is if each of it cells is in a different window. In that case, no additional blue cells can be added: it's fully surrounded by red.
Finally, for any $k$-omino with $k>4$, one can find a tetromino as a subset. (Proof: take the orthogonal adjacency graph of the $k$-omino, choose a spanning tree, and delete leaves from the tree until there are only four vertices left.)
Remark (Common wrong approach). Suppose Ruby employs the following algorithm whenever Blake places a square $x$. If either the north and west neighbors of $x$ are unoccupied, place red squares on both of them. With any leftover red squares, place them at other neighbors of $x$ if possible. Finally, place any other red squares arbitrarily. (Another variant, the one Evan originally came up with, is to place east if possible when west is occupied, place south if possible when north is occupied, and then place any remaining red squares arbitrarily.)
As written, this strategy does not work. The reason is that one can end up in the following situation (imagine the blue square in the center is played first; moves for Ruby are drawn as red X's):

In order to prevent Blake from winning, Ruby would need to begin playing moves not adjacent to Blake's most recent move.

Thus in order for this solution to be made correct, one needs a careful algorithm for how Ruby should play when the north and west neighbors are not available. As far as I am aware, there are some specifications that work (and some that don't), but every working algorithm I have seen seems to involve some amount of casework.

It is even more difficult to come up with a solution involving playing on just "some" two neighbors of recently added blue squares without the "prefer north and west" idea.