diff --git a/Readme.md b/Readme.md
index 6fbc37d..b9e647c 100644
--- a/Readme.md
+++ b/Readme.md
@@ -1,57 +1,25 @@
 # KorAP Repo Manifest
 
-This repository is primarily aimed at developers who want to build KorAP or one of its components or related tools themselves.
+This repository is aimed at developers and others who want to build KorAP or one of its components or related tools.
 
 It helps to check out all necessary repositories using [Repo](https://source.android.com/setup/develop/repo), a tool built by the Android development team to manage multi-repository projects.
 
 ## Getting started
 
-### Create the directories
-
-You’ll need to set up some directories in your build environment.
-
-To create them:
-
-```bash
-mkdir -p ~/bin
-mkdir -p ~/KorAP
-```
-
-The ~/bin directory will contain the git-repo tool (commonly named “repo”) and the ~/KorAP directory will contain the source code of KorAP.
-
 ### Install the `repo` command
 
-Enter the following to download the repo binary and make it executable (runnable):
+Follow the [repo installation instructions](https://gerrit.googlesource.com/git-repo#install).
 
-```bash
-curl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repo
-chmod a+x ~/bin/repo
-```
-
-### Put the `~/bin` directory in your path of execution
-
-In recent versions of Ubuntu, `~/bin` should already be in your PATH. You can check this by opening `~/.profile` with a text editor and verifying the following code exists (add it if it is missing):
-
-```bash
-# set PATH so it includes user's private bin if it exists
-if [ -d "$HOME/bin" ] ; then
-    PATH="$HOME/bin:$PATH"
-fi
-```
-
-### Configure git
-
-Given that repo requires you to identify yourself to sync KorAP sources, run the following commands to configure your git identity:
-
-```bash
-git config --global user.email "you@example.com"
-git config --global user.name "Your Name"
-```
 
 ### Initialize the KorAP source repositories
 
 ```bash
-cd ~/KorAP
+mkdir KorAP
+cd KorAP
 repo init -u https://korap.ids-mannheim.de/gerrit/KorAP/manifest
 repo sync
 ```
+
+### Learn how start and upload KorAP changes for review
+
+See the [repo command reference](https://source.android.com/docs/setup/develop/repo).
