diff --git a/docs/buildkit/civibuild.md b/docs/buildkit/civibuild.md
new file mode 100644
index 0000000000000000000000000000000000000000..19f5fe451c1a917c4b757d9e98784942c6f33b7b
--- /dev/null
+++ b/docs/buildkit/civibuild.md
@@ -0,0 +1,265 @@
+# civibuild
+
+Creating a full development environment for CiviCRM requires a lot of work, e.g.
+
+ * Downloading / installing / configuring a CMS (Drupal, Joomla, WordPress)
+ * Downloading / installing / configuring CiviCRM
+ * Configuring Apache and MySQL
+ * Configuring file permissions on data folders
+ * Configuring a headless test database for phpunit
+ * Configuring Selenium to connect to Civi
+
+The *civibuild* command automates this process. It includes different
+build-types that are useful for core development, such as *drupal-clean* (a
+barebones Drupal+Civi site) and *wp-demo* (a WordPress+Civi site with some
+example content).
+
+Note: There are a number of build tools on the market which can, e.g.,
+create a Drupal web site (like [drush](http://drush.ws/)) or WordPress web
+site (like [wp-cli](http://wp-cli.org/)).  Civibuild does not aim to replace
+these.  Unfortunately, such tools generally require extra work for a Civi
+developer environment.  Civibuild works with these tools and and fills
+in missing parts.
+
+## Your First Build
+
+!!! tip
+    Login as a non-`root` user who has `sudo` permission. This will ensure that new files are owned by a regular user, and (if necessary) it enables `civibuild` to restart Apache or edit `/etc/hosts`.
+
+The first build requires only a few commands.  However, these are also the
+hardest commands -- you need to provide detailed information about the
+Apache/MySQL/PHP systems, and you may need to try them a few times.
+
+Configure `amp` with details of your Apache/MySQL environment.  Pay close
+attention to the instructions.  They may involve adding a line to your
+Apache configuration file.
+
+```
+$ amp config
+```
+
+Test that `amp` has full and correct information about Apache/MySQL.
+
+```
+$ amp test
+```
+
+!!! note
+    You may need to alternately restart httpd, re-run `amp config`, and/or re-run `amp test` a few times.
+
+Create a new build using Drupal and the CiviCRM `master` branch.
+The command will print out URLs and credentials for accessing the website.
+
+```
+$ civibuild create dmaster --url http://dmaster.localhost --admin-pass s3cr3t
+```
+
+Once you have a working build of `dmaster`, you can continue working with `civibuild` to create different builds (as described below) or [learn more about other day-to-day development tasks](/buildkit/tutorials).
+
+## Build Types
+
+`civibuild` includes a small library of build scripts for different
+configurations.
+
+For a list of available build-types as well as documentation on writing build scripts,
+see `app/config` within your buildkit installation.
+
+For example, at time of writing, it includes:
+
+* `backdrop-clean`: A bare, "out-of-the-box" installation of Backdrop+CiviCRM
+* `backdrop-demo`: A demo site running Backdrop and CiviCRM
+* `backdrop-empty`: An empty Backdrop site (without CiviCRM). Useful for testing tarball installation.
+* `drupal8-clean`: A bare, "Out of the box" Installation of Druapl8+CiviCRM.
+* `druapl8-demo` : A demo site running Drupal8 and CiviCRM.
+* `drupal-clean`: A bare, "out-of-the-box" installation of Drupal+CiviCRM.
+* `drupal-demo`: A demo site running Drupal and CiviCRM.
+* `drupal-empty`: An empty Drupal site (without CiviCRM). Useful for testing tarball installation.
+* `joomla-empty`: An empty Joomla site (without CiviCRM). Useful for testing tarball installation.
+* `wp-demo`: A demo site running WordPress and CiviCRM
+* `wp-empty`: An empty WordPress site (without CiviCRM). Useful for testing tarball installation.
+* `hrdemo` A demo site running Drupal, CiviCRM, and CiviHR
+* `symfony`: An experimental hybrid site running Drupal 7, Symfony 2, and CiviCRM
+* `cxnapp`: A self-signed CiviConnect app based on the reference implementation.
+* `messages`: A backend service for delivering in-app messages (eg "Getting Started").
+* `extdir`: A mock website akin to civicrm.org/extdir/ . Useful for testing the extension download process.
+* `dist`: A website containing nightly builds akin to dist.civicrm.org. Useful for preparing CiviCRM tarballs.
+* `distmgr`: A service which manages redirects and report-backs for the download site.
+* `l10n`: WIP - A build environment for creating translation files.
+* `joomla-demo`: WIP/incomplete/broken
+
+Build types can be mixed/matched with different versions of Civi, e.g.
+
+```bash
+$ civibuild create my-drupal-civi47 \
+  --type drupal-demo \
+  --civi-ver master \
+  --url http://my-drupal-civi47.localhost
+$ civibuild create my-drupal-civi46 \
+  --type drupal-demo \
+  --civi-ver 4.6 \
+  --url http://my-drupal-civi46.localhost
+$ civibuild create my-wordpress-civi4719 \
+  --type wp-demo \
+  --civi-ver 4.7.19 \
+  --cms-ver 4.0 \
+  --url http://my-wp-civi4719.localhost
+```
+
+The `--civi-ver` argument will accept any branch or version tag.  *Note: the 4.7 version is in the `master` branch.*.
+
+You can also specify `--patch` with a pull request URL to apply those changes on top of your CiviCRM version.
+
+## Build Aliases
+
+For developers who work with several CMSs and several versions of Civi, it's
+useful to have a naming convention and shorthand for the most common
+configurations.  Civibuild includes aliases (in `src/civibuild.aliases.sh`)
+like "d44" and "wpmaster":
+
+Create a build "d44" using build-type "drupal-demo" with Civi "4.4"
+
+```
+$ civibuild create d44 --url http://d44.localhost
+```
+
+Create a build "d45" using build-type "drupal-demo" with Civi "4.5"
+
+```
+$ civibuild create d45 --url http://d45.localhost
+```
+
+Create a build "wp45" using build-type "wp-demo" with Civi "4.5"
+
+```
+$ civibuild create wp45 --url http://wp45.localhost
+```
+
+Create a build "wpmaster" using build-type "wp-demo" with Civi's "master" branch
+
+```
+$ civibuild create wpmaster --url http://wpmaster.localhost
+```
+
+These aliases exactly match the demo sites deployed under civicrm.org (e.g.
+"wp45" produces the demo site "wp45.demo.civicrm.org").
+
+## Rebuilds
+
+If you're interested in working on the build types or build process, then the workflow will consist of alternating two basic steps: (1) editing build scripts and (2) rebuilding. Rebuilds may take a few minutes, so it's helpful to choose the fastest type of rebuild that will meet your needs.
+
+There are four variations on rebuilding. In order of fastest (least thorough) to slowest (most thorough):
+
+<table>
+  <thead>
+  <tr>
+    <th>Command</th>
+    <th>Description</th>
+    <th>Civibuild Metadata</th>
+    <th>Civi+CMS Code</th>
+    <th>Civi+CMS Config</th>
+    <th>Civi+CMS DB</th>
+  </tr>
+  </thead>
+  <tbody>
+  <tr>
+    <td><b>civibuild restore &lt;name&gt;</b></td>
+    <td>Restore DB from pristine SQL snapshot</td>
+    <td>Preserve</td>
+    <td>Preserve</td>
+    <td>Preserve</td>
+    <td>Destroy / Recreate</td>
+  </tr>
+  <tr>
+    <td><b>civibuild reinstall &lt;name&gt;</b></td>
+    <td>Rerun CMS+Civi "install" process</td>
+    <td>Preserve</td>
+    <td>Preserve</td>
+    <td>Destroy / Recreate</td>
+    <td>Destroy / Recreate</td>
+  </tr>
+  <tr>
+    <td><b>civibuild create &lt;name&gt; --force</b></td>
+    <td>Create site, overwriting any files or DBs</td>
+    <td>Preserve</td>
+    <td>Destroy / Recreate</td>
+    <td>Destroy / Recreate</td>
+    <td>Destroy / Recreate</td>
+  </tr>
+  <tr>
+    <td><b>civibuild destroy &lt;name&gt; ; civibuild create &lt;name&gt;</b></td>
+    <td>Thoroughly destroy and recreate everything</td>
+    <td>Destroy / Recreate</td>
+    <td>Destroy / Recreate</td>
+    <td>Destroy / Recreate</td>
+    <td>Destroy / Recreate</td>
+  </tr>
+  </tbody>
+</table>
+
+## civicrm.settings.php; settings.php; wp-config.php
+
+There are a few CiviCRM settings which are commonly configured on a per-server
+or per-workstation basis. For example, civicrm.org's demo server has ~10
+sites running different builds (Drupal/WordPress/CiviHR),
+and visitors should not be allowed to download new extensions on any of those
+sites. However, on the training server, trainees should be allowed to download
+extensions. As discussed in
+[Override CiviCRM Settings](https://wiki.civicrm.org/confluence/display/CRMDOC/Override+CiviCRM+Settings),
+this setting (and many others) can be configured in civicrm.settings.php.
+
+The `civicrm.settings.php` is created automatically as part of the build. One
+could edit the file directly, but that means editing civicrm.settings.php
+after every (re)build. The easiest way to customize the settings is to put
+extra `.php` files in `/etc/civicrm.settings.d` &mdash; these files will be loaded
+on every site that runs on this server (regardless of how many sites you
+create or how many times you rebuild them).
+
+For more details on how `civicrm.settings.d` works, see `/app/civicrm.settings.d/README.txt` within your buildkit installation.
+
+A parallel structure exists for the CMS settings files. See also:
+
+* `/app/drupal.settings.d/README.txt`
+* `/app/wp-config.d/README.txt`
+
+## Development/Testing of `civibuild`
+
+The tests for `civibuild` are stored in `tests/phpunit`.  These are
+integration tests which create and destroy real builds on the local system.
+To run them:
+
+* Configure `amp` (as above)
+* Ensure that a test site is configured (`civibuild create civibild-test --type empty`)
+* Run `phpunit4` or `env DEBUG=1 OFFLINE=1 phpunit4`
+    * Note that the tests accept some optional environment variables:
+        * `DEBUG=1` - Display command output as it runs
+        * `OFFLINE=1` - Try to avoid unnecessary network traffic
+
+
+## Experimental: Multiple demo/training sites
+
+When creating a batch of identical sites for training or demonstrations,
+one may want to create a single source-code-build with several
+databases/websites running on top (using "Drupal multi-site"). To install
+extra sites,  use the notation "civibuild create buildname/site-id" as in:
+
+Create the original build
+
+```
+$ civibuild create training --type drupal-demo --civi-ver 4.5 --url http://demo00.example.org --admin-pass s3cr3t
+```
+
+Create additional sites (01 - 03)
+
+```
+$ civibuild create training/01 --url http://demo01.example.org --admin-pass s3cr3t
+$ civibuild create training/02 --url http://demo02.example.org --admin-pass s3cr3t
+$ civibuild create training/03 --url http://demo03.example.org --admin-pass s3cr3t
+```
+
+Alternatively, create additional sites (01 - 20)
+
+```bash
+$ for num in $(seq -w 1 20) ; do
+  civibuild create training/${num} --url http://demo${num}.example.org --admin-pass s3cr3t
+done
+```
diff --git a/docs/buildkit/cividist.md b/docs/buildkit/cividist.md
new file mode 100644
index 0000000000000000000000000000000000000000..5af9b8ee93b82f28d33dc43e95bd4d05e658ce81
--- /dev/null
+++ b/docs/buildkit/cividist.md
@@ -0,0 +1,75 @@
+## CiviDist
+
+`cividist` generates a website with tarballs built from the official git repos ([civicrm-core.git](https://github.com/civicrm/civicrm-core.git), [civicrm-packages.git](https://github.com/civicrm/civicrm-packages.git), etc). It manages the CiviCRM [nightly builds](http://dist.civicrm.org).
+
+If you wish to run `cividist` with your own repos, you will need to do the some initial setup and then periodically build new tarballs.
+
+`cividist` expects that branch names match across all repos (e.g. the `4.6` branch in `civicrm-core.git` must match the `4.6` branch in `civicrm-packages.git`). If you use a non-standard branch name, it must exist in all repos.
+
+## Setup: Make the web root
+
+```
+civibuild create dist --url http://dist.localhost
+```
+
+## Setup: Register your forks
+
+!!! note
+    If you use forks, you should do so consistently across all repos (even if you don't have any customizations on one repo or another). The goal is to consistently name the `remote`s and `branch`es across all repos.
+
+```
+cd build/dist/src
+git remote add myfork https://github.com/myfork/civicrm-core.git
+
+cd build/dist/src/drupal
+git remote add myfork https://github.com/myfork/civicrm-drupal.git
+
+cd build/dist/src/packages
+git remote add myfork https://github.com/myfork/civicrm-packages.git
+
+cd build/dist/src/joomla
+git remote add myfork https://github.com/myfork/civicrm-joomla.git
+
+cd build/dist/src/Wordpress
+git remote add myfork https://github.com/myfork/civicrm-wordpress.git
+```
+
+## Setup: Permissions
+
+If your system has specific permission requirements, then apply the permissions as you normally would. For example, if you use chgrp and and set all files as group-writable:
+
+```
+sudo git config --system core.filemode false
+sudo chgrp -R mygroup build/dist
+sudo chmod -R g+w build/dist
+```
+
+## Periodic: Update tarballs
+
+This will retrieve the latest code from the remote alias (eg `myfork`) and build new build tarballs:
+
+```
+cd build/dist
+env GIT_REMOTE=myfork cividist update 
+cividist build myfork/4.6
+```
+
+By default the tarballs will have the date in the name. If you don't want this you can add a FILE_SUFFIX
+e.g to this command is used by Fuzion to a) use a remote called 'fuzion', b) use the branch 4.6.4rc1 from those repos & c) output using filenames like civicrm-4.6.5-drupal-nightly.tar.gz
+
+```
+env FILE_SUFFIX=nightly cividist build fuzion/4.6.4rc1
+```
+
+You can also build multiple tarballs with one command, e.g.
+
+```
+cividist build myfork/4.5 myfork/4.6 myfork/master
+```
+
+## Periodic: Cleanup old/orphaned tarballs
+
+```
+cd build/dist
+cividist prune
+```
diff --git a/docs/buildkit/index.md b/docs/buildkit/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..2db343548105e7a0908371720246362928b6049c
--- /dev/null
+++ b/docs/buildkit/index.md
@@ -0,0 +1,139 @@
+# Buildkit
+
+[Buildkit](https://github.com/civicrm/civicrm-buildkit) is a collection of ~20 tools for developing and testing CiviCRM, the most important of which is [civibuild](/buildkit/civibuild.md).
+
+Many of these tools are commonly used by web developers, so you may have already installed a few. Even so, it's generally easier to [install](/buildkit/setup) the full collection &mdash; installing each individually takes a lot of work.
+
+This is the same collection of tools which manages the test/demo/release infrastructure for civicrm.org.
+
+
+## Installation
+
+### Ubuntu
+
+If you have a new installation of Ubuntu 12.04 or 14.04, then you can download
+everything -- buildkit and the system requirements -- with one command. This
+command will install buildkit to `~/buildkit`:
+
+```bash
+curl -Ls https://civicrm.org/get-buildkit.sh | bash -s -- --full --dir ~/buildkit
+```
+
+Note:
+
+ * When executing the above command, you should *not* run as `root`. However, you *should*
+have `sudo` permissions.
+ * The `--full` option is *very opinionated*; it specifically installs `php`, `apache`, and `mysql` (rather than `hvm`, `nginx`, `lighttpd`, or `percona`). If you try to mix `--full` with alternative systems, then expect conflicts.
+ * If you use the Ubuntu feature for "encrypted home directories", then don't put buildkit in `~/buildkit`. Consider `/opt/buildkit`, `/srv/buildkit`, or some other location that remains available during reboot.
+
+### Vagrant
+
+[Full Download: Vagrantbox](https://github.com/civicrm/civicrm-buildkit-vagrant) - Download a prepared virtual-machine with all system dependencies (mysql, etc). This is ideal if you work on Windows or OS X.
+
+
+### Docker
+
+If you have [Docker](https://www.docker.com/) running, you can [use this Docker image](https://github.com/ErichBSchulz/dcbk) to run buildkit.
+
+
+
+### Other platforms
+
+You may install buildkit in other environments. The main pre-requisites are:
+
+* Linux or OS X
+* Git
+* PHP 5.3+ (Extensions: `bcmath curl gd gettext imap intl imagick json mbstring mcrypt openssl pdo_mysql phar posix soap zip`)
+* NodeJS (v5 recommended)
+* NPM
+* Recommended (_for [amp](https://github.com/totten/amp) and [civibuild](/buildkit/civibuild.md)_)
+    * Apache 2.2 or 2.4 (Modules: `mod_rewrite`. On SUSE, possibly `mod_access_compat`. This list may not be exhaustive.)
+    * MySQL 5.1+ (client and server)
+
+All pre-requisites must support command-line access using the standard command
+names (`git`, `php`, `node`, `mysql`, `mysqldump`, etc). In some environments,
+you may need to enable these commands by configuring `PATH` -- this is especially
+true for MAMP, XAMPP, and other downloaded packages.
+(See, e.g., [Setup Command-Line PHP](http://wiki.civicrm.org/confluence/display/CRMDOC/Setup+Command-Line+PHP).)
+
+Once the pre-requisites are met, download buildkit to `~/buildkit`:
+
+```bash
+git clone https://github.com/civicrm/civicrm-buildkit.git ~/buildkit
+cd ~/buildkit
+./bin/civi-download-tools
+```
+
+### Troubleshooting
+
+* Nodejs version too old or npm update does not work
+
+Download the latest version from nodejs.org and follow to their instructions
+
+* Nodejs problems
+
+It might be handy to run
+
+```bash
+npm update
+npm install fs-extra
+```
+
+
+## Configuring buildkit after installation
+
+!!! note "Not needed for Vagrant/Docker installations"
+    If you set up buildkit using Vagrant or Docker, then you don't need to perform the configuration steps listed here.
+
+Buildkit includes many CLI commands in the `bin/` folder.
+
+You may execute the commands directly (e.g.  `./bin/civix` or `/path/to/buildkit/bin/civix`).  However, this would
+become very cumbersome.  Instead, you should configure the shell's `PATH` to recognize these commands automatically.
+
+!!! tip
+    Throughout this document, we will provide examples which assume that buildkit was downloaded to `/path/to/buildkit`. Be sure to adjust the examples to match your system.
+
+If you want to ensure that the buildkit CLI tools are always available, then:
+
+1. Determine the location of your shell configuration file. This is usually `~/.bashrc`, `~/.bash_profile`, or
+`~/.profile`.
+1. At the end of the file, add `export PATH="/path/to/buildkit/bin:$PATH"`
+1. Close and reopen the terminal.
+1. Enter the command `which civibuild`. This should display a full-path. If nothing appears, then retry the steps.
+
+
+!!! note
+
+    Buildkit includes specific versions of some fairly popular tools (such as `drush`, `phpunit`, and `wp-cli`), and it's possible that you have already installed other versions of these tools.
+
+    By design, buildkit can coexist with other tools, but you must manually manage the `PATH`.
+
+    Whenever you wish to use buildkit, manually run a command like, e.g.:
+
+    ```bash
+    export PATH=/path/to/buildkit/bin:$PATH
+    ```
+
+    To restore your normal `PATH`, simply close the terminal and open a new one.
+
+    Each time you open a new terminal while working on Civi development, you would need to re-run the `export` command.
+
+
+
+## Upgrading buildkit
+
+New versions of buildkit are likely to include new versions of tools. The
+new tools will download automatically when you first run `civibuild`.
+If you prefer to download explicitly, then re-run `civi-download-tools`.
+
+The configurations and tools in buildkit are periodically updated. To get the latest, simply run:
+
+```bash
+cd ~/buildkit
+git pull
+./bin/civi-download-tools
+```
+
+See the [buildkit changelog](https://github.com/civicrm/civicrm-buildkit/blob/master/CHANGELOG.md) for info about specific changes to buildkit.
+
+
diff --git a/docs/basics/debugging.md b/docs/tools/debugging.md
similarity index 100%
rename from docs/basics/debugging.md
rename to docs/tools/debugging.md
diff --git a/docs/tools/index.md b/docs/tools/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..c25e376db2a8984039a860c0f0a1c9a8cca8e6e7
--- /dev/null
+++ b/docs/tools/index.md
@@ -0,0 +1,73 @@
+# Development tools
+
+## CiviCRM-specific tools
+
+All of these tools come bundled within [buildkit](/buildkit).
+
+* `civibuild` - Build a complete source tree (with CMS+Civi+addons), provision httpd/sql, etc.
+    * *[documentation](/buildkit/civibuild.md)*
+    * *[repository](https://github.com/civicrm/civicrm-buildkit)*
+* `cv` - command is a utility for interacting with a CiviCRM installation
+    * *documentation: run `cv list`*
+    * *[repository](https://github.com/civicrm/cv)*
+* `civix` - Generate skeletal code for CiviCRM extensions
+    * *[documentation](/extensions/civix)*
+    * *[repository](https://github.com/totten/civix)*
+* `civistrings` - Scan code for translatable strings (*.pot)
+    * *documentation: run `civistrings --help`*
+    * *[repository](https://github.com/civicrm/civistrings)*
+* `cividist` - Generate tarballs from a series of git branches/tags
+    * *[documentation](/buildkit/cividist)*
+    * *repository: [within civicrm-buildkit](https://github.com/civicrm/civicrm-buildkit/blob/master/bin/cividist)*
+* `gitify` - Convert a CiviCRM installation to a git repo
+    * *documentation: run `gitify` with no arguments*
+    * *repository: [within civicrm-buildkit](https://github.com/civicrm/civicrm-buildkit/blob/master/bin/gitify)*
+* `civilint` - Check the syntax of uncommitted files using `phpcs`, `jshint`, etc.
+    * *documentation: run `civilint` with no arguments*
+    * *repository: [within civicrm-buildkit](https://github.com/civicrm/civicrm-buildkit/blob/master/bin/civilint)*
+* `civihydra` - Create a series test sites for several CMSs (extends `civibuild`)
+    * *documentation: run `civihydra` with no arguments*
+    * *repository: [within civicrm-buildkit](https://github.com/civicrm/civicrm-buildkit/blob/master/bin/civihydra)*
+* `civicrm-upgrade-test` - Scripts and data files for testing upgrades
+    * *[documentation& repository](https://github.com/civicrm/civicrm-upgrade-test)*
+* Coder - Configure phpcs for CiviCRM's [coding standards](http://wiki.civicrm.org/confluence/display/CRMDOC/PHP+Code+and+Inline+Documentation)
+    * *[documentation & repository](https://github.com/civicrm/coder)*
+    * *(Derived from [Drupal's coder project](https://www.drupal.org/project/coder))*
+
+
+## External tools installed with buildkit
+
+These tools are not specific to CiviCRM, so you may already have some of them installed on your system.
+
+If you install [buildkit](/buildkit) you'll get all these tools at once, in addition to the CiviCRM-specific tools listed above.
+
+* Dependency management
+    * [composer](http://getcomposer.org/) - Manage dependencies for PHP code.
+    * [bower](http://bower.io/) - Manage dependencies for Javascript code.
+* Source code management
+    * [git-scan](https://github.com/totten/git-scan/) - Manage a large number of git repositories.
+    * [hub](http://hub.github.com/) - Send commands to github.com.
+* Source code quality
+    * [jshint](http://jshint.com/) - Check the syntax of Javascript files.
+    * [phpcs](https://github.com/squizlabs/PHP_CodeSniffer) - Check the syntax of PHP files.
+ * Site management
+    * [amp](https://github.com/totten/amp) - Abstracted interface for local httpd/sql service (Apache/nginx/MySQL).
+    * [drush](http://drush.ws/) - Administer a Drupal site.
+    * [joomla](https://github.com/joomlatools/joomla-console) (joomla-console) - Administer a Joomla site.
+    * [wp](http://wp-cli.org/) (wp-cli) - Administer a WordPress site.
+* Testing
+    * [karma](http://karma-runner.github.io) (w/[jasmine](http://jasmine.github.io/)) - Unit testing for Javascript.
+    * [paratest](https://github.com/brianium/paratest) - Parallelized version of PHPUnit.
+    * [phpunit](http://phpunit.de/) - Unit testing for PHP (with Selenium and DB add-ons).
+
+## Other useful tools
+
+### Text editors
+
+If you already have a text editor you love, then stick to that. If you're new and need some recommendations, here are some of the most popular text editors among CiviCRM developers:
+
+* [PhpStorm](https://www.jetbrains.com/phpstorm/) *(See [CiviCRM-specific notes on PhpStorm](/tools/phpstorm))*
+* [NetBeans](https://netbeans.org/)
+* [Sublime](https://www.sublimetext.com/)
+* [Atom](https://atom.io/)
+* [vim](http://www.vim.org/)
diff --git a/docs/tools/phpstorm.md b/docs/tools/phpstorm.md
new file mode 100644
index 0000000000000000000000000000000000000000..6f3bf4428c5376241748505111cefcde46acfec5
--- /dev/null
+++ b/docs/tools/phpstorm.md
@@ -0,0 +1,38 @@
+# Using PhpStorm for CiviCRM Development
+
+[PhpStorm](https://www.jetbrains.com/phpstorm) is a commercial IDE which is popular among CiviCRM developers.
+
+
+## General project setup
+
+* Use the root directory of your CMS as your project root (otherwise in-app debugging won't work)
+* You can speed up PhpStorm's indexing process by taking the following steps to ignore most files:
+    1. Settings > Directories
+    1. Mark all directories as "Excluded"
+    1. Drill down to find the "civicrm" folder and mark it as "Sources"
+
+## Code style setup
+
+Create the 'CiviCRM' code styling preference:
+
+1. Open you current project's properties: File > Settings
+1. Create the CiviCRM code styling preference: Code Style > Manage > Save as, then indicate 'CiviCRM'
+1. In the 'Code style' sub-menu, select 'PHP', then 'Set from ...' at the far right, Predefined Style > Drupal (this sets options across all tabs of the dialog)
+1. In the 'Code style' sub-menu, select 'Javascript', then 'Set from ...' at the far right, PHP (this replicates all PHP settings to the Javascript section)
+1. Click 'Apply' at the bottom of the screen
+
+That's it. You can now use this code style on all future CiviCRM-related projects. If you are only developing for CiviCRM, you can also copy this style to the 'Default' style.
+
+
+## Running CiviCRM's automated tests from within PhpStorm
+
+TODO: write this section, drawing on some content here:
+
+https://wiki.civicrm.org/confluence/display/CRMDOC/Tests+in+phpstorm
+
+
+## XDebug integration
+
+TODO
+
+
diff --git a/mkdocs.yml b/mkdocs.yml
index f6e3d3402f736a370d13e762bbcca47ac0ac043a..5aba33c0f7205e1e09c8cd46c1569b6cd938a050 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -11,8 +11,14 @@ pages:
   - Useful Skills: basics/skills.md
   - Planning Your Project: basics/planning.md
   - File System: basics/filesystem.md
-  # buildkit: /setup/buildkit.md   # summary: See Github README for download instructions. Alternatively, follow links and install particular tools as-needed.
-  - Debugging: basics/debugging.md
+- Development tools:
+  - Development tools: tools/index.md
+  - PhpStorm: tools/phpstorm.md
+  - Debugging: tools/debugging.md
+- Buildkit:
+  - Buildkit: buildkit/index.md
+  - civibuild: buildkit/civibuild.md
+  - cividist: buildkit/cividist.md
 - Core Development:
   - When to Edit Core: core/hacking.md
   - How to Contribute: core/contributing.md
diff --git a/redirects/internal.txt b/redirects/internal.txt
index 0074fbdb6e8e30a6a36813c8161f776f639d40d3..e1c4b5b25f372da2f0916e7250668ae280b06216 100644
--- a/redirects/internal.txt
+++ b/redirects/internal.txt
@@ -1,4 +1,4 @@
-dev-tools/debugging basics/debugging
+dev-tools/debugging tools/debugging
 extend-stages extensions/lifecycle
 markdownrules documentation/markdown
 best-practices/documentation-style-guide documentation/style-guide