What does group theory add to the understanding of error correcting codes? I'm learning about group codes. Here's how I understand it (please correct me if I'm wrong):

*

*$\mathbb{Z}_2^n$ under xor is an abelian group.

*$\text{syn}: \mathbb{Z}_2^n \rightarrow \mathbb{Z}_2^n$, the syndrome function, is a homomorphism.

*The kernel of this homomorphism is, by definition, the set of codewords. Let's call it $C$. Being a kernel, it's also a normal subgroup.

*It can also be shown that $C$ is generated by the rows of the parity check matrix of the code.

*By the Fundamental Homomorphism Theorem, $\mathbb{Z}_2^n / C \cong \text{Im}\ syn$. So, every coset corresponds to a different syndrome and the elements in a given coset all have the same syndrome.

*From the item above, it follows that the received message and the error pattern that generated it (from the sent codeword) are in the same coset.

*Finally, choose the element with smallest number of $1$s (the coset leader). Let's call it $\mathbf{e}$. And let's call the received word $\mathbf{r}$. The codeword to be reconstructed is $\mathbf{e} + \mathbf{r}$.

Now, we can explain the same thing without any reference to group theoretical concepts, and dealing only with matrices instead. Even in the explanation above, we have to use matrices anyway. So it doesn't seem to be adding anything to understanding of this type of code.
But, of course, I'm missing something. What is it? Is there any insight we can get by looking at this subject from a group theoretical perspective, that we wouldn't get otherwise? Does it make the implementation of algorithms easier?
 A: For error-correcting codes, the geometry is really the natural thing for which to ask. That is, we want code words to be sufficiently far apart, so that we can easily detect and correct errors. In order to measure distance, we have some sort of metric. This metric induces a geometry on the space.
Now if we want to compute things, it is often helpful to have additional structure on the space. Algebra is really about computation, and so asking for algebraic structure is a very natural thing to do. This motivates group codes. Namely, do our code words form a (sub)group? If the answer is yes, then we now have additional algebraic structure to help us make sense of our code!
In the case when the group is a field (such as $\mathbb{Z}_{2}$), we can (as you have pointed out) reduce to the case of linear algebra, which is very well understood both mathematically and algorithmically. In particular, reducing to linear algebra allows for very efficient computations. Syndrome decoding, for example, is very efficient in the linear algebraic setting. Because of all these reasons, it is very nice when we can reduce to linear algebra without any issues!
Now in your case, since $\mathbb{Z}_{2}$ is a field, the individual codewords generate one-dimensional subspaces of $\mathbb{Z}_{2}^{n}$, while the codespace is a vector subspace of $\mathbb{Z}_{2}^{n}$. Matrices are precisely linear transformations from one vector space to another. It is nice to think about the parity-check matrix $H$ (i.e., the syndrome map) as a linear transformation, for which the code space $C$ is the kernel (or the nullspace, if you prefer). So if $e$ is our error and $x$ is a codeword, then $H(x+e) = Hx + He$ by linearity. As $x \in \text{ker}(H)$, we have that $Hx = 0$. So $H(x+e) = He$.
In practice, we will compute $H(x+e)$. However, the linear algebra machinery provides that if $H(x+e) \neq 0$, then an error was made. Furthermore, we can look up the error corresponding to the output $H(x+e) = He$.
Now vector spaces are Abelian groups with some additional structure. So folks sometimes prefer to use the language of group theory. However, if you are comfortable with the linear algebra, it is perfectly fine to talk about these as vector spaces.
One natural question to ask is how much of this generalizes when we are working over an arbitrary cyclic group $\mathbb{Z}_{n}$ (i.e., when $n$ is not necessarily prime).  I am not entirely sure how much of this breaks. One thing to point out is that while $\mathbb{Z}_{n}$ and $\mathbb{Z}_{p}$ ($p$ is prime) have the same additive structure as groups, their ring structures (when incorporating addition and multiplication) are very different. $\mathbb{Z}_{p}$ is a field, while $\mathbb{Z}_{n}$ fails to even be an integral domain. Namely, if $n$ is not prime, there are non-zero elements $a, b \in \mathbb{Z}_{n}$ such that $ab = 0$. This does not happen when we have a field.
In the case of general rings $R$, we want our codes to be sub-modules of the $R$-module $R^{n}$ rather than just additive subgroups of $R^{n}$. The sub-module condition is closer in analogy to a vector subspace than an additive subgroup, as the sub-module requires closure under both addition and scalar multiplication. When dealing with $R$-modules, the goal is often times to see what linear algebraic tools we can apply.
I'm not an expert in general group codes. There is some work in generalizing linear codes (such as codes over $\mathbb{Z}_{2}^{n}$) to the setting of $R$-modules, when the ring $R$ is nicely behaved. One such class of ring is the class of Galois rings, which are used to construct Galois codes. This undergraduate honors thesis might serve as a gentle introduction to the area (https://www.whitman.edu/documents/Academics/Mathematics/2016/Holdman.pdf). It is helpful to have a group theoretic perspective, as well as a linear algebraic perspective, when looking at these more general settings.
