diff --git a/docs/docs/development.rst b/docs/docs/development.rst
index 57816a04..22ce71e4 100644
--- a/docs/docs/development.rst
+++ b/docs/docs/development.rst
@@ -149,15 +149,15 @@ Fast Parser (parser/fast.py)
 
 .. _docstrings:
 
-Docstrings (docstrings.py)
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+Docstrings (evaluate/docstrings.py)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. automodule:: jedi.evaluate.docstrings
 
 .. _refactoring:
 
-Refactoring (refactoring.py)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Refactoring (evaluate/refactoring.py)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. automodule:: jedi.refactoring
 
@@ -175,25 +175,24 @@ Imports & Modules
 
 .. _builtin:
 
-Compiled Modules (compiled.py)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Compiled Modules (evaluate/compiled.py)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. automodule:: jedi.evaluate.compiled
 
+
 .. _imports:
 
-
-Imports (imports.py)
-~~~~~~~~~~~~~~~~~~~~
+Imports (evaluate/imports.py)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. automodule:: jedi.evaluate.imports
 
 
-
 .. _caching-recursions:
 
 Caching & Recursions
-----------------------
+--------------------
 
 
 - :ref:`Caching <cache>`
@@ -214,16 +213,14 @@ Recursions (recursion.py)
 .. automodule:: jedi.evaluate.recursion
 
 
-
 .. _dev-helpers:
 
 Helper Modules
 ---------------
 
-There are some helper modules: `common.py`, `helpers.py`, `debug.py`,
-`keywords.py`, which I won't describe further. Some functions are inheritely
-important and central for Jedi to work, but not important to understand how
-Jedi works.
+Most other modules are not really central to how Jedi works. They all contain
+relevant code, but you if you understand the modules above, you pretty much
+understand Jedi.
 
 Python 2/3 compatibility (_compatibility.py)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
diff --git a/jedi/evaluate/__init__.py b/jedi/evaluate/__init__.py
index 74d49c76..d441e503 100644
--- a/jedi/evaluate/__init__.py
+++ b/jedi/evaluate/__init__.py
@@ -1,8 +1,8 @@
 """
 Evaluation of Python code in |jedi| is based on three assumptions:
 
-* Code is recursive (to weaken this assumption, the :mod:`dynamic` module
-  exists).
+* Code is recursive (to weaken this assumption, the
+  :mod:`jedi.evaluate.dynamic` module exists).
 * No magic is being used:
 
   - metaclasses
@@ -37,7 +37,7 @@ This is exactly where it starts to get complicated. Now recursions start to
 kick in. The statement has not been resolved fully, but now we need to resolve
 the datetime import. So it continues
 
-- follow import, which happens in the :mod:`imports` module.
+- follow import, which happens in the :mod:`jedi.evaluate.imports` module.
 - now the same ``eval_call`` as above calls ``follow_path`` to follow the
   second part of the statement ``date``.
 - After ``follow_path`` returns with the desired ``datetime.date`` class, the
diff --git a/jedi/evaluate/docstrings.py b/jedi/evaluate/docstrings.py
index 8a65221d..dac52e1d 100644
--- a/jedi/evaluate/docstrings.py
+++ b/jedi/evaluate/docstrings.py
@@ -1,8 +1,8 @@
 """
 Docstrings are another source of information for functions and classes.
-:mod:`dynamic` tries to find all executions of functions, while the docstring
-parsing is much easier. There are two different types of docstrings that |jedi|
-understands:
+:mod:`jedi.evaluate.dynamic` tries to find all executions of functions, while
+the docstring parsing is much easier. There are two different types of
+docstrings that |jedi| understands:
 
 - `Sphinx <http://sphinx-doc.org/markup/desc.html#info-field-lists>`_
 - `Epydoc <http://epydoc.sourceforge.net/manual-fields.html>`_
diff --git a/jedi/evaluate/representation.py b/jedi/evaluate/representation.py
index 5451e472..2a47c405 100644
--- a/jedi/evaluate/representation.py
+++ b/jedi/evaluate/representation.py
@@ -1,6 +1,7 @@
 """
-Like described in the :mod:`parsing_representation` module, there's a need for
-an ast like module to represent the states of parsed modules.
+Like described in the :mod:`jedi.evaluate.parsing_representation` module,
+there's a need for an ast like module to represent the states of parsed
+modules.
 
 But now there are also structures in Python that need a little bit more than
 that. An ``Instance`` for example is only a ``Class`` before it is