anchor.diff:   => #<Todo:21964520>
   ```
   
  -### Defining Elements
  -
  -Adding things to the assembly requires an assembly definition file. By convention this is
  -named `config/assembly.rb` and is built using a simple DSL. There are
  -a handful of different element types in Assemblies. Below are a few of the
  -most common. Full documentation of the DSL can be found at http://alki.io[alki.io].
  -
  +[[defining-elements]]
  +=== Defining Elements
  +
  +Adding things to the assembly requires an Assembly definition file.
  +By convention this is named `config/assembly.rb` and is built using a DSL.
  +There are a handful of different element types in Assemblies.
   Elements can refer to other elements, and can be defined in any order.
   
  -.config/assembly.rb
  -```ruby
  -Alki do
  -  group :settings do <1>
  -    set(:home) { ENV['HOME'] } <2>
  -    set(:db_path) { ENV['TODO_DB_PATH'] || File.join(home,'.todo_db') }
  -    set :prompt, 'todo> '
  -  end
  -
  -  service :interface do <3>
  +Full documentation of the DSL can be found http://alki.io/dsl/[here].
  +
  +Below is an example Assembly definition for the todo application
  +which uses a few of the core element types.
  +
  +.config/assembly.rb
  +```ruby
  +Alki do
  +  load :settings
  +
  +  service :interface do
       require 'todo/readline_interface'
       Todo::ReadlineInterface.new settings.prompt, handler
     end
  
positive.code: => 'todo> '
  ```
  
  ### Creating an executable
  
  Read more about creating executables with Alki
  http://alki.io/executables.html[here].
  
  In the todo example, it's a CLI utility so it requires an executable.
  The executable just needs to require the main project file,
  create a new instance of the assembly,
  and call a method on a service.
  
  .exe/todo
  ```ruby
  require 'todo'
  Todo.new.interface.run
  ```
  
  ### Splitting up the Assembly configuration
  
  As a project grows, it's helpful to be able to split out
  parts of the Assembly configuration into multiple files.
  
  This can be accomplished with the `load` method in the DSL,
  which will load the named file and add it the elements
  defined in it as a group in the assembly.
  
  For example, it's common to split out application settings into
  a separate config file.
  
  .config/settings.rb
  ```ruby
  Alki do
   set(:home) { ENV['HOME'] }
   set(:db_path) { ENV['TODO_DB_PATH'] || File.join(home,'.todo_db') }
   set :prompt, 'todo> '
  end
  ```
  
  .config/assembly.rb
  ```ruby
  Alki do
    load :settings
  
    service :interface do
      require 'todo/readline_interface'
      Todo::ReadlineInterface.new settings.prompt, handler
    end
  
    ...
  end
  ```
  
  ## Further Documentation
  
  Further documentation can be found at http://alki.io[alki.io].
  
  Example projects can be found https://github.com/alki-project/alki-examples[here]
  
  ## Authors
  
  Written by Matt Edlefsen
  
negative.code: 
  ```
  
  The http://alki.io/projects/alki-console.html[alki-console] developer console gem can also be used to quickly work with assemblies.
  It can be used by adding `gem 'alki-console'` to the Gemfile and running `bundle --binstubs` to add the console script to the 'bin' directory.
  
  Elements can be accessed directly without having to manually create an
  assembly instance.
  
  ```
  $ bin/alki-console
  