diff --git a/renderScript/BasicRenderScript/Application/AndroidManifest.xml b/renderScript/BasicRenderScript/Application/AndroidManifest.xml
index 1e35dc3..21c3a62 100644
--- a/renderScript/BasicRenderScript/Application/AndroidManifest.xml
+++ b/renderScript/BasicRenderScript/Application/AndroidManifest.xml
@@ -4,9 +4,7 @@
     android:versionCode="1"
     android:versionName="1.0" >
 
-    <uses-sdk
-        android:minSdkVersion="8"
-        android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:allowBackup="true"
diff --git a/renderScript/BasicRenderScript/Application/src/main/AndroidManifest.xml b/renderScript/BasicRenderScript/Application/src/main/AndroidManifest.xml
index e1e2dfc..3bc65ff 100644
--- a/renderScript/BasicRenderScript/Application/src/main/AndroidManifest.xml
+++ b/renderScript/BasicRenderScript/Application/src/main/AndroidManifest.xml
@@ -20,9 +20,7 @@
     android:versionCode="1"
     android:versionName="1.0">
 
-    <uses-sdk
-        android:minSdkVersion="8"
-        android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <application
         android:allowBackup="true"
diff --git a/renderScript/BasicRenderScript/Application/tests/AndroidManifest.xml b/renderScript/BasicRenderScript/Application/tests/AndroidManifest.xml
index 02a8db3..34eca02 100644
--- a/renderScript/BasicRenderScript/Application/tests/AndroidManifest.xml
+++ b/renderScript/BasicRenderScript/Application/tests/AndroidManifest.xml
@@ -20,9 +20,7 @@
           android:versionCode="1"
           android:versionName="1.0">
 
-    <uses-sdk
-            android:minSdkVersion="8"
-            android:targetSdkVersion="19" />
+    <!-- Min/target SDK versions (<uses-sdk>) managed by build.gradle -->
 
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
