increase of encoding rate increases bandwidth?
As per @JasonR's suggestion (but no longer succinct...., though
hopefully still correct...)

Error-control coding creates redundant symbols that are also transmitted
over the channel. A simple description of what happens is as follows.
The data symbols are divided into chunks of $k$ (data)
symbols and to each such chunk is appended a chunk of $n-k$
redundant symbols to create a codeword of $n$ symbols. The
rate of the code is $R = \frac{k}{n}$ since $n$ symbols must
be transmitted over the channel in order to get $k$ data symbols
across more reliably. The device that
creates and appends the redundant symbols is called an encoder.
Note that the encoder accepts $k$ symbols as input and spits
out $n &gt; k$ symbols as output.  Now, it is possible for the encoder
to send the $n$ symbols to the transmitter for transmission using the
system and signaling design, modulation method that is already
set up. In this case, the channel signaling rate is not changed
at all and so the bandwidth remains the same. However, 
the codeword, consisting of $n$ symbols, takes longer 
to transmit than the $k$ data symbols would have using the
same transmitter and channel that we have available.
There is also the issue of what happens to the next chunk of
$k$ data symbols that are knocking at the encoder input while
the encoder is still busy sending the redundant symbols to
the transmitter.  So this scheme can be implemented if
we don't really care about how long it takes to transmit
the data (which is presumed to be a finite-length file or
audio track (say) and not a (potentially) infinite never-ending
stream of data all of which needs to be delivered to the
receiver, and are willing to have lots of buffers
between the encoder and the transmitter to save the codewords
being generated until the transmitter gets around to transmitting
them.  We will also need buffers at the receiver where the
redundant symbols will be stripped off, and the data
symbols delivered to the destination in chunks of $k$
symbols followed by $n-k$ intervals of dead silence: buffering
can be used to save the $k$ symbol chunks and patch them
into a continuous stream of data.

The alternative, which most people opt for, is to modify
the transmitter and receiver so that each channel symbol
takes less time (by a factor of $R$) to be transmitted,
so that the $n$ symbols of the codeword can be transmitted
in the same time that the $k$ data symbols would have been in
absence of error-control coding. The increase in the
signaling rate means that the transmitter output requires a
larger bandwidth (by a factor of $R^{-1}$) for transmission. 
The channel thus must have larger bandwidth too, which can
create problems if wireless channels are being used.
Frequency bands are allotted by government agencies and if
your transmitter is already using the full spectrum allotted
to you, a Plan B and a complete re-design might be needed.
These systems with larger bandwidth also need buffers
at the transmitting end as well as the receiving end,
but only two relatively small ones of $k$ symbols at both
ends. The two buffers precede the encoder and are used
in ping-pong fashion. The data source is reading in
$k$ symbols into one buffer, say one symbol every $T$
seconds, and thus taking a total of $kT$ seconds to fill
the buffer. During this time, the encoder reads out
the $k$ data symbols from the other previously filled buffer
at a rate of one symbol every $RT$ seconds for a total
of $k(RT)$ seconds. The data symbols are also sent on to
the transmitter while the $n-k$ redundant symbols are created
within the encoder, which then spends the remaining
$kT-k(RT) = (n-k)(RT)$ seconds sending the $n-k$ redundant
symbols to the transmitter at a rate of one every $RT$
seconds.  At the end of a $kT$ second
period, the data source starts to fill the buffer just
emptied by the encoder, while the encoder starts to
accept data from the buffer just filled by the data
source. If you are still following all this, note
that the encoder and the transmitter are working 
with a clock that is running at a higher rate 
(by a factor of $R^{-1}$) than
the clock of the data source, while the clock
signals to the buffers are alternately at the
low rate (when connected to data source) and
at high rate (when connected to encoder).
Similar things occur in reverse between the
receiver output and the data destination
but I will skip the details.

A third alternative, as pointed out by Bryan, 
is to change the modulation format
on the channel so that, for example, instead of transmitting one channel bit
with each channel symbol (as in BPSK), you transmit more channel bits per
symbol (e.g. use QPSK to send two bits per channel symbol). In this case,
there need not be any increase in bandwidth (which is primarily determined
by the symbol rate (rate in baud)). A common use of the BPSK/QPSK usage
is the use of rate-$\frac{1}{2}$ convolutional coding which would double
the bandwidth if BPSK were used, but by switching to QPSK, the bandwidth 
remains the same even when coding is used. However, as also noted by Bryan,
the transmitter and receiver become more complicated.