diff --git a/test/git-scripts/README.md b/test/git-scripts/README.md
deleted file mode 100644
index 6bd9110..0000000
--- a/test/git-scripts/README.md
+++ /dev/null
@@ -1,16 +0,0 @@
-README for git hooks script
-===========================
-git has a way to run scripts, which are invoked by specific git commands.
-The git hooks are located in `<mbed TLS root>/.git/hooks`, and as such are not under version control
-for more information, see the [git documentation](https://git-scm.com/docs/githooks).
-
-The mbed TLS git hooks are located in `<mbed TLS root>/test/git-scripts` directory, and one must create a soft link from `<mbed TLS root>/.git/hooks` to `<mbed TLS root>/test/git-scripts`, in order to make the hook scripts successfully work.
-
-Example:
-
-Execute the following command to create a link on linux from the mbed TLS `.git/hooks` directory:  
-`ln -s ../../test/git-scripts/pre-push.sh pre-push`
-
-**Note: Currently the mbed TLS git hooks work only on a GNU platform. If using a non-GNU platform, don't enable these hooks!**
-
-These scripts can also be used independently.
diff --git a/test/git-scripts/pre-push.sh b/test/git-scripts/pre-push.sh
deleted file mode 100755
index ee54a6c..0000000
--- a/test/git-scripts/pre-push.sh
+++ /dev/null
@@ -1,47 +0,0 @@
-#!/bin/sh
-# pre-push.sh
-#
-# This file is part of mbed TLS (https://tls.mbed.org)
-#
-# Copyright (c) 2017, ARM Limited, All Rights Reserved
-#
-# Purpose
-#
-# Called by "git push" after it has checked the remote status, but before anything has been
-# pushed.  If this script exits with a non-zero status nothing will be pushed.
-# This script can also be used independently, not using git.
-#
-# This hook is called with the following parameters:
-#
-# $1 -- Name of the remote to which the push is being done
-# $2 -- URL to which the push is being done
-#
-# If pushing without using a named remote those arguments will be equal.
-#
-# Information about the commits which are being pushed is supplied as lines to
-# the standard input in the form:
-#
-#   <local ref> <local sha1> <remote ref> <remote sha1>
-#
-
-REMOTE="$1"
-URL="$2"
-
-echo "REMOTE is $REMOTE"
-echo "URL is $URL"
-
-set -eu
-
-run_test()
-{
-    TEST=$1
-    echo "running '$TEST'"
-    if ! `$TEST > /dev/null 2>&1`; then
-        echo "test '$TEST' failed"
-        return 1
-    fi
-}
-
-run_test ./tests/scripts/check-doxy-blocks.pl
-run_test ./tests/scripts/check-names.sh
-run_test ./tests/scripts/check-generated-files.sh
