diff --git a/faq/CommitterFAQ.xml b/faq/CommitterFAQ.xml
index 047feaa..de962ae 100644
--- a/faq/CommitterFAQ.xml
+++ b/faq/CommitterFAQ.xml
@@ -11,7 +11,7 @@
   <entry id="git_1" category="Build/Git">
     <question>Where are the source code repositories for the webtools project?</question>
 	<answer>
-	WTP's source code repositories are hosted on Eclipse.org and accessed through Gerrit. The following pages allow browsing the repositories and list the current cloning URLs at the bottom of the respective pages.
+	WTP's source code repositories are hosted on Eclipse.org and accessed through Gerrit. The following pages allow browsing the repositories and list the current cloning URLs at the bottom of the respective pages:<br/>
 	<a href="https://git.eclipse.org/c/gerrit/webtools-common/webtools.common.git">webtools.common</a><br/>
 	<a href="https://git.eclipse.org/c/gerrit/dali/webtools.dali.git">webtools.dali</a><br/>
 	<a href="https://git.eclipse.org/c/gerrit/jeetools/webtools.javaee.git">webtools.javaee</a><br/>
@@ -282,15 +282,14 @@
     	<p>
     		The following comment should be placed in each provisional API class description:<br />
     		<br />
-    		* &lt;p&gt;<br />
- 			* &lt;b&gt;Note:&lt;/b&gt; This class/interface is part of an interim API that is still under development and expected to<br />
- 			* change significantly before reaching stability. It is being made available at this early stage to solicit feedback<br />
-			* from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken<br />
-			* (repeatedly) as the API evolves.<br />
- 			* &lt;/p&gt;
- 		</p>
- 		<p>
- 			See the WST <a href="http://dev.eclipse.org/viewcvs/index.cgi/wst/components/server/plugins/org.eclipse.wst.server.core/servercore/org/eclipse/wst/server/core/IModule.java?rev=1.12&amp;cvsroot=WebTools_Project&amp;content-type=text/vnd.viewcvs-markup" target="_top">Server core plug-in</a> for an example.
+        <pre>
+* <p>
+* <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+* change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+* from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+* (repeatedly) as the API evolves.
+* </p>
+      </pre>
  		</p>
     </answer>
   </entry>
diff --git a/faq/stylesheets/faqphoenix.xsl b/faq/stylesheets/faqphoenix.xsl
index 67db49d..5891247 100644
--- a/faq/stylesheets/faqphoenix.xsl
+++ b/faq/stylesheets/faqphoenix.xsl
@@ -118,7 +118,7 @@
             <xsl:call-template name="heading">
                 <xsl:with-param name="title" select="@name" />
                 <xsl:with-param name="alink" select="@name" />
-                <xsl:with-param name="toplink" select="'#toc'" />
+<!--                 <xsl:with-param name="toplink" select="'#toc'" /> -->
             </xsl:call-template>
             <xsl:variable name="catname" select="@name" />
             <ol>
