diff --git a/connectivity/network/NetworkConnect/_index.jd b/connectivity/network/NetworkConnect/_index.jd
deleted file mode 100644
index f9d507b..0000000
--- a/connectivity/network/NetworkConnect/_index.jd
+++ /dev/null
@@ -1,13 +0,0 @@
-
-
-
-page.tags="NetworkConnect"
-sample.group=NoGroup
-@jd:body
-
-<p>
-            
-            This sample demonstrates how to connect to the network and fetch raw HTML using
-            HttpURLConnection. AsyncTask is used to perform the fetch on a background thread.
-            
-        </p>
diff --git a/content/LoaderCursor/loadercursor.jd b/content/LoaderCursor/loadercursor.jd
deleted file mode 100644
index dba0a0f..0000000
--- a/content/LoaderCursor/loadercursor.jd
+++ /dev/null
@@ -1,14 +0,0 @@
-page.title=LoaderCursor Sample
-@jd:body
-
-<p>This sample demonstrates the use of the 
-<pre><a href="http://developer.android.com/reference/android/app/LoaderManager.html">LoaderManager
-</a></pre> to retrieve data from a 
-<pre><a href="http://developer.android.com/reference/android/database/Cursor.html">Cursor</a></pre>
-.</p>
-
-<p>Here, a list of contacts is displayed in a 
-<pre><a href="http://developer.android.com/reference/android/app/ListFragment.html">ListFragment
-</a></pre> and filtered using a 
-<pre><a href="http://developer.android.com/reference/android/widget/SearchView.html">SearchView
-</a></pre> ActionBar item.</p>
\ No newline at end of file
diff --git a/content/contacts/BasicContactables/_index.jd b/content/contacts/BasicContactables/_index.jd
deleted file mode 100644
index 3bab7ea..0000000
--- a/content/contacts/BasicContactables/_index.jd
+++ /dev/null
@@ -1,11 +0,0 @@
-page.tags="BasicContactables"
-sample.group=NoGroup
-@jd:body
-
-<p>
-            
-    Welcome to Basic Contactables Query sample!\n\n
-    Use the search box to enter a term, and find matching contacts in
-    Android\'s contact database!
-
-</p>
diff --git a/input/multitouch/BasicMultitouch/_index.jd b/input/multitouch/BasicMultitouch/_index.jd
deleted file mode 100644
index 2d7bdc5..0000000
--- a/input/multitouch/BasicMultitouch/_index.jd
+++ /dev/null
@@ -1,14 +0,0 @@
-
-
-
-page.tags="BasicMultitouch"
-sample.group=NoGroup
-@jd:body
-
-<p>
-    This samples demonstrates the use of MotionEvent properties to keep track of individual touches
-    across multiple touch events.
-</p><p>
-    Touch the screen with multiple fingers to show that the pointer id
-    (also represented by a colour) does not change as new touch events are received.</string>
-</p>
diff --git a/media/BasicMediaRouter/_index.jd b/media/BasicMediaRouter/_index.jd
deleted file mode 100644
index 4bba1a5..0000000
--- a/media/BasicMediaRouter/_index.jd
+++ /dev/null
@@ -1,17 +0,0 @@
-
-
-
-page.tags="BasicMediaRouter"
-sample.group=NoGroup
-@jd:body
-
-<p>
-            
-            This sample demonstrates the use of the MediaRouter API to display
- content on a secondary display.\n\nUse the "Media Route Action Item" in the ActionBar
- to select an output device. If your device supports Miracast wireless displays,
- you may need to enable "Wireless Display" functionality in the system settings.
- Secondary screen simulation can also be enabled from the "Developer Options".\n\n
-Once connected, use the "Change Color" button to change the background color of the secondary screen.
-            
-        </p>
diff --git a/ui/actionbar/DoneBar/_index.jd b/ui/actionbar/DoneBar/_index.jd
deleted file mode 100644
index 287a04a..0000000
--- a/ui/actionbar/DoneBar/_index.jd
+++ /dev/null
@@ -1,18 +0,0 @@
-
-
-
-page.tags="DoneBar"
-sample.group=UI
-@jd:body
-
-<p>
-            
-                This sample demonstrates two alternative presentations of the
-                action bar that are well-suited for simple data entry scenarios.
-
-                In this presentation, a done bar replaces the action
-                bar entirely, providing two direct actions to persist or dismiss changes. This is
-                suitable for cases where no additional view details or actions are needed in the
-                action bar.
-            
-        </p>
diff --git a/ui/actionbarcompat/Basic/_index.jd b/ui/actionbarcompat/Basic/_index.jd
deleted file mode 100644
index 17ddfda..0000000
--- a/ui/actionbarcompat/Basic/_index.jd
+++ /dev/null
@@ -1,15 +0,0 @@
-
-
-
-page.tags="Basic"
-sample.group=NoGroup
-@jd:body
-
-<p>
-            
-            This sample shows you how to use ActionBarCompat to create a basic Activity which
-            displays action items. It covers inflating items from a menu resource, as well as adding
-            an item in code. Items that are not shown as action items on the Action Bar are
-            displayed in the action bar overflow.
-            
-        </p>
diff --git a/ui/actionbarcompat/ListPopupMenu/_index.jd b/ui/actionbarcompat/ListPopupMenu/_index.jd
deleted file mode 100644
index 00e6628..0000000
--- a/ui/actionbarcompat/ListPopupMenu/_index.jd
+++ /dev/null
@@ -1,13 +0,0 @@
-
-
-
-page.tags="ListPopupMenu"
-sample.group=NoGroup
-@jd:body
-
-<p>
-            
-            This sample shows you how to use {@link android.support.v7.widget.PopupMenu PopupMenu}
-            from ActionBarCompat to create a list, with each item having a dropdown menu.
-            
-        </p>
diff --git a/ui/actionbarcompat/ShareActionProvider/_index.jd b/ui/actionbarcompat/ShareActionProvider/_index.jd
deleted file mode 100644
index 36784ff..0000000
--- a/ui/actionbarcompat/ShareActionProvider/_index.jd
+++ /dev/null
@@ -1,13 +0,0 @@
-
-
-
-page.tags="ShareActionProvider"
-sample.group=NoGroup
-@jd:body
-
-<p>
-            
-            This sample shows you how a provide a context-sensitive ShareActionProvider with
-            ActionBarCompat, backwards compatible to API v7.
-            
-        </p>
diff --git a/ui/actionbarcompat/Styled/_index.jd b/ui/actionbarcompat/Styled/_index.jd
deleted file mode 100644
index fd79264..0000000
--- a/ui/actionbarcompat/Styled/_index.jd
+++ /dev/null
@@ -1,13 +0,0 @@
-
-
-
-page.tags="Styled"
-sample.group=NoGroup
-@jd:body
-
-<p>
-            
-            This sample shows you how to use ActionBarCompat with a customized theme. It utilizes a
-            split action bar when running on a device with a narrow display, and show three tabs.
-            
-        </p>
diff --git a/ui/holo/BorderlessButtons/_index.jd b/ui/holo/BorderlessButtons/_index.jd
deleted file mode 100644
index 2c17d3a..0000000
--- a/ui/holo/BorderlessButtons/_index.jd
+++ /dev/null
@@ -1,11 +0,0 @@
-
-
-
-page.tags="BorderlessButtons"
-sample.group=NoGroup
-@jd:body
-
-<p>
-        This sample demonstrates the use of borderless buttons, bottom button bars
-        (OK and Cancel) and dividers to establish visual structure.
-</p>
diff --git a/ui/notifications/BasicNotifications/_index.jd b/ui/notifications/BasicNotifications/_index.jd
deleted file mode 100644
index 9556b29..0000000
--- a/ui/notifications/BasicNotifications/_index.jd
+++ /dev/null
@@ -1,14 +0,0 @@
-
-
-
-page.tags="BasicNotifications"
-sample.group=NoGroup
-@jd:body
-
-<p>
-            
-            This sample demonstrates how to display events in the system\'s notification bar. The
-            NotificationCompat API is used for compatibility with older devices, running Android
-            2.2 (Froyo) or newer.
-            
-        </p>
diff --git a/ui/views/HorizontalPaging/_index.jd b/ui/views/HorizontalPaging/_index.jd
deleted file mode 100644
index 160621e..0000000
--- a/ui/views/HorizontalPaging/_index.jd
+++ /dev/null
@@ -1,13 +0,0 @@
-
-
-
-page.tags="HorizontalPaging"
-sample.group=NoGroup
-@jd:body
-
-<p>
-            
-            This sample demonstrates how to implement horizontal paging between fragments in
-            applications that use ActionBar, using a ViewPager widget.
-            
-        </p>
diff --git a/ui/window/AdvancedImmersiveMode/_index.jd b/ui/window/AdvancedImmersiveMode/_index.jd
deleted file mode 100644
index 2faca3c..0000000
--- a/ui/window/AdvancedImmersiveMode/_index.jd
+++ /dev/null
@@ -1,14 +0,0 @@
-
-
-
-page.tags="AdvancedImmersiveMode"
-sample.group=UI
-@jd:body
-
-<p>
-            
-            \"Immersive Mode\" is a new UI mode which improves \"hide full screen\" and
-            \"hide nav bar\" modes, by letting users swipe the bars in and out.  To try it out,
-            enable \"Immersive Mode\" using the checkbox below and click \"Try these settings!\"
-            
-        </p>
diff --git a/ui/window/BasicImmersiveMode/_index.jd b/ui/window/BasicImmersiveMode/_index.jd
deleted file mode 100644
index fc4ff9c..0000000
--- a/ui/window/BasicImmersiveMode/_index.jd
+++ /dev/null
@@ -1,13 +0,0 @@
-
-
-
-page.tags="BasicImmersiveMode"
-sample.group=UI
-@jd:body
-
-<p>
-            
-            Introductory text that explains what the sample is intended to demonstrate. Edit
-            in template-params.xml.
-            
-        </p>
diff --git a/ui/window/ImmersiveMode/_index.jd b/ui/window/ImmersiveMode/_index.jd
deleted file mode 100644
index 7c9a272..0000000
--- a/ui/window/ImmersiveMode/_index.jd
+++ /dev/null
@@ -1,14 +0,0 @@
-
-
-
-page.tags="ImmersiveMode"
-sample.group=UI
-@jd:body
-
-<p>
-            
-            One of the features introduced in KitKat is "immersive mode". Immersive mode gives the
-            user the ability to show/hide the status bar and navigation bar with a swipe.  To try,
-            click the "Toggle immersive mode" button, then try swiping the bar in and out!
-            
-        </p>
diff --git a/views/TextLinkify/_index.jd b/views/TextLinkify/_index.jd
deleted file mode 100644
index 987fb62..0000000
--- a/views/TextLinkify/_index.jd
+++ /dev/null
@@ -1,13 +0,0 @@
-
-
-
-page.tags="TextLinkify"
-sample.group=NoGroup
-@jd:body
-
-<p>
-            
-            This sample illustrates how links can be added to a TextView. This can be done either
-            automatically by setting the "autoLink" property or explicitly.
-            
-        </p>
