# Git Katas: deliberate Git practice through isolated exercises

> Git Katas is a collection of self-contained exercises for learners, instructors, and developers who need deliberate Git practice. It covers many commands and history-management workflows, but each exercise requires finding the solution rather than following a completed script.

**eficode-academy/git-katas** — A set of exercises for deliberate Git Practice

- Repository: https://github.com/eficode-academy/git-katas
- Stars: 1,695 · Forks: 1,103
- Language: Shell
- License: MIT
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/eficode-academy-git-katas

## What Git Katas trains beyond command recall

Git Katas addresses a specific gap between recognizing Git commands and using them without a guided tutorial. Each exercise is intended to be self-contained, which makes the repository suitable for Git course instruction, workshop preparation, individual study, or periodic revision. The README says the exercises can help learners keep their Git skills sharp. That framing matters because Git contains many stateful commands whose effect depends on the current branch, staging area, working tree, and commit history.

The collection begins with entry-level material and becomes substantially broader. The suggested path starts with `basic-commits`, `basic-staging`, `investigation`, and `basic-branching`. It then moves through fast-forward and three-way merges, rebase, revert, reset, cleaning, amend, history reordering, interactive rebase, autosquash, and stashing. Other top-level directories indicate exercises for topics such as cherry-pick, bisect, detached heads, tags, ignored files, submodules, subtree work, signed commits, merge drivers, and Git LFS.

This is practice through repository state, not a quiz interface. The repository provides folders containing exercise instructions and setup scripts, while the learner must inspect the resulting state and determine which Git operations are needed. That design rewards explanation and experimentation. It also means that Git Katas is less appropriate for someone who wants a single executable validator or a lesson that supplies every command in advance.

## Repository layout and exercise execution model

The visible architecture is a directory of independent exercises. `Overview.md` serves as the catalog and contains a more complete exercise list and suggested order. Each selected exercise has its own README, and the top-level README directs users to run a `setup.sh` script inside the exercise directory. Based on this documented flow, setup initializes or prepares the exercise's Git repository, after which the learner reads the local instructions and changes the repository to meet the goal.

The top-level files also suggest repository-wide checking, including `test.sh`, `testzsh.sh`, `test.ps1`, and `test-all.sh`. Their names indicate coverage across Unix shells, Zsh, and PowerShell, although the README does not document the exact commands or explain the test output. It would therefore be unsafe to claim that these scripts validate every exercise or describe their passing criteria.

The exercises target effects across several Git layers. A commit exercise affects history and author metadata. Staging exercises distinguish working-tree changes from index changes. Branching and merge exercises change graph structure. Rebase, reorder, and squash exercises rewrite local commit sequences. Investigation, diff, log, and history exercises require reading existing state rather than creating a new state. This breadth is the project's main strength, but it also means there is no single learning path suitable for every learner. `basic-` exercises are explicitly identified as entry-level, while other exercises vary considerably in difficulty.

## Local installation and the first Basic Commits exercise

The README's local workflow begins with cloning the repository, changing into an exercise directory, running `setup.sh`, and reading that directory's `README.md`. Its documented clone URL uses `praqma-training` rather than the `enicode-academy` repository name. That inconsistency matters to a new user. Confirm that the URL resolves to the intended repository before using it.

The README supplies this clone command:

```shell
git clone https://github.com/praqma-training/git-katas.git
```

After the clone succeeds, enter the `basic-commits` directory, which is the first exercise in the README's suggested learning path. The top-level documentation names the script but does not specify whether it must be invoked as `sh setup.sh` or another form, so follow the invocation documented by the local exercise instructions. The documented script name is:

```shell
setup.sh
```

The expected result is the repository state prepared for that exercise. Then open `basic-commits/README.md` and follow its task rather than applying commands from the top-level cheatsheet automatically. The cheatsheet lists useful inspection commands:

```shell
git status
git diff
git diff --cached
git log --oneline
```

Use those commands to inspect the actual repository before changing it. The first exercise should be treated as a diagnosis: determine which files and commits the instructions require, then verify the final state with Git's status and history views. The README does not publish a separate automated validator result for this first use, so success should be judged against the exercise's local instructions rather than an assumed console message.

## Progression from staging to history rewriting

The recommended sequence is not simply a catalogue dump. It moves from creating commits and controlling the index toward operations that reshape commit history. `basic-staging` establishes the distinction between unstaged and staged changes. `investigation` introduces reading history and state. `basic-branching`, `ff-merge`, and `3-way-merge` then establish graph navigation and integration before the path reaches `merge-mergesort`, `rebase-branch`, and the history-editing exercises.

This ordering reflects Git's dependency structure. A learner who cannot distinguish the index from the working tree will have difficulty reasoning about `git reset <file>`, `git commit --amend`, or commands that move a branch reference while preserving selected states. Likewise, merge conflicts are easier to interpret after basic history inspection has become familiar. Rebase and autosquash should come after ordinary branch and merge operations because they require understanding parent commits, branch ancestry, and rewritten commit identities.

The top-level cheatsheet provides command examples, not task solutions. For example, it lists `git rebase master`, but the exact command needed by a rebase kata depends on that exercise's starting branches and required result. The same applies to `git stash`, `git branch -D my-branch`, and the three `git reset` modes shown with optional or positional arguments. Treating the cheatsheet as a catalog can help, but copying an example without reading repository state risks changing more history than an exercise intended.

The collection is broad enough that instructors can select a path for a lesson rather than requiring an entire class to complete every directory. Self-learners should still avoid jumping directly to `advanced-rebase-interactive` unless the earlier concepts are already familiar.

## Git Katas limitations and operational boundaries

The primary limitation is limited guidance. The README describes the purpose, broad topics, and entry workflow, but it does not publish sample starting states, completed solutions, expected final logs, or grading output for individual exercises. Local exercise READMEs must therefore carry the task-specific information. If a learner does not understand the repository layout or knows only the broad topic name, selecting an exercise is not enough to predict its difficulty.

The project is also not a simulation of every remote Git operation. The visible exercise list includes many local history and working-tree operations, but the truncated cheatsheet's remote section does not provide enough instructions to claim complete coverage of fetch, pull, push, remotes, or hosted collaboration. The repository includes `pre-push`, which indicates at least one relevant exercise, yet its detailed behavior is not documented in the top-level README.

Git exercises also carry a genuine data-loss boundary. Commands shown in the cheatsheet include `git reset --soft [commit_hash]` and warn that `--hard` discards changes. Other examples include force-deleting a branch with `git branch -D my-branch`. The README warns not to amend after pushing because the exercise project treats public history as changed. Git Katas is intended for disposable practice repositories, not experimentation in an active production repository.

Finally, setup scripts reduce manual work but do not replace understanding. If a setup script does not produce the state described in its local README, or if a learner's global Git configuration changes available behavior, the exercise may diverge from its intended starting condition. The README documents editor configuration examples but does not describe compatibility across every Git version or operating system.

## Maintenance, releases, and MIT use

The repository is not archived, and the last push was on 2026-10-16. Those facts indicate recent repository activity, but they do not by themselves guarantee that every exercise is correct or that every topic is covered evenly. The release history contains version `0.4.0` dated 2026-01-26, `0.3.0` dated 2021-10-29, and `0.2.0` dated 2020-11-09. The substantial gap before `0.4.0` means that the project does not appear to follow a frequent release cadence, even though recent push activity exists.

Maintenance effort for adopters is mostly content maintenance rather than runtime operation. There is no server component in the described workflow. Users clone the repository and run exercise scripts locally. An instructor may need to inspect scripts and local READMEs before class, especially when selecting a lesson sequence. Contributors can submit pull requests for missing exercises or corrections, and the project explicitly invites issues when problems are found.

The repository is licensed under the MIT License through `LICENSE.txt`. That permits broad use, modification, and redistribution subject to the license terms, including preservation of its copyright and permission notice. This article does not provide legal advice. For classroom redistribution or incorporation into internal training material, the actual `LICENSE.txt` should be reviewed and retained as required.

## Conclusion

Git Katas fits self-directed learners who want command-level Git practice and instructors who can structure lessons around discovered answers. It is a poor fit for developers seeking a GUI, a reference manual, or guided remediation for production incidents. Verify first that your intended exercise appears in Overview.md and that its setup.sh creates the repository state described by the local README. For this repository, that verification also includes checking the documented `praqma-training/git-katas.git` clone URL against the `enicode-academy/git-katas` repository identity.

## FAQ

### How do I install and start Git Katas on my local machine?

Clone the repository, change into the directory for the exercise you want, run its `setup.sh`, and consult that directory's `README.md`. The documented clone URL uses `https://github.com/praqma-training/git-katas.git`, which differs from the `enicode-academy/git-katas` repository name and should be verified.

### Does Git Katas provide solutions for its Git exercises?

The repository is described as a collection of exercises, and its workflow directs learners to run a setup script and consult the exercise README. The README does not say that completed solutions are included.

### Which Git Katas exercise should a beginner complete first?

The suggested learning path starts with `basic-commits`, followed by `basic-staging`, `investigation`, and `basic-branching`. Exercises beginning with `basic` are described as entry-level, while difficulty varies across the rest of the collection.

## Sources

- [eficode-academy/git-katas on GitHub](https://github.com/eficode-academy/git-katas)
- [Issues](https://github.com/eficode-academy/git-katas/issues)
- [License: MIT](https://github.com/eficode-academy/git-katas/blob/master/LICENSE)
- [README](https://github.com/eficode-academy/git-katas/blob/master/README.md)
- [Releases](https://github.com/eficode-academy/git-katas/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/eficode-academy-git-katas