diff --git a/src/main/java/org/apache/maven/reporting/exec/MavenReportExecution.java b/src/main/java/org/apache/maven/reporting/exec/MavenReportExecution.java
index 9257916..7731755 100644
--- a/src/main/java/org/apache/maven/reporting/exec/MavenReportExecution.java
+++ b/src/main/java/org/apache/maven/reporting/exec/MavenReportExecution.java
@@ -24,12 +24,12 @@
 
 /**
  * <p>
- *   Since Maven 3, reporting plugin {@link MavenReport} are not anymore executed by Maven core.
- *   This class will store all necessary information for {@link MavenReport} execution:
+ *   Since Maven 3, reporting plugin {@link MavenReport} are not anymore prepared by Maven core.
+ *   This class will store all necessary information for {@link MavenReport} generation:
  *   <ul>
  *     <li>a {@link MavenReport},</li>
  *     <li>the goal name associated to the report,</li>
- *     <li>the associated {@link ClassLoader} for the Report Mojo execution,</li>
+ *     <li>the associated {@link ClassLoader} for the report generation,</li>
  *     <li>the {@link Plugin} associated to the {@link MavenReport}.</li>
  *   </ul> 
  * </p>
diff --git a/src/main/java/org/apache/maven/reporting/exec/MavenReportExecutor.java b/src/main/java/org/apache/maven/reporting/exec/MavenReportExecutor.java
index b1fdfeb..7289930 100644
--- a/src/main/java/org/apache/maven/reporting/exec/MavenReportExecutor.java
+++ b/src/main/java/org/apache/maven/reporting/exec/MavenReportExecutor.java
@@ -25,14 +25,19 @@
 import org.apache.maven.reporting.MavenReport;
 
 /**
- * This component will build {@link MavenReport}s.
- * If a {@link MavenReport} needs to fork a lifecycle, this fork is executed.
+ * This component will execute (prepare) {@link MavenReport}s for later generation.
+ * If a {@link MavenReport} needs to fork a goal or a lifecycle phase, this fork is executed.
+ * <p>Notice that Maven Reports are classical {@link org.apache.maven.plugin.Mojo Mojos} implementing
+ * the {@link MavenReport} interface: when used as reports, their <code>Mojo.execute()</code> method is
+ * not used.</p> 
  *
  * @author Olivier Lamy
  */
 public interface MavenReportExecutor
 {
     /**
+     * Build the {@link MavenReport}s, with associated forked executions if necessary. 
+     * 
      * @param mavenReportExecutorRequest
      * @return Maven report execution results
      * @throws MojoExecutionException
diff --git a/src/site/apt/index.apt.vm b/src/site/apt/index.apt.vm
index 2daa17d..83dafae 100644
--- a/src/site/apt/index.apt.vm
+++ b/src/site/apt/index.apt.vm
@@ -75,7 +75,7 @@
 
   []
 
-  Maven 3 core makes an automatic transformation of <<<\<reporting\>>>> POM section to <<<maven-site-plugin>>>
-  configuration through the
+  Maven 3 core makes an automatic transformation of <<<\<reporting\>>>> POM section (which supports configuration inheritance)
+  to <<<maven-site-plugin>>>'s <<<reportPlugins>>> configuration through the
   {{{/ref/current/maven-model-builder/apidocs/org/apache/maven/model/plugin/ReportingConverter.html}ReportingConverter}}
   component.
