diff --git a/Makefile b/Makefile
index c9883af..aa0c21b 100644
--- a/Makefile
+++ b/Makefile
@@ -12,6 +12,8 @@
 
 GENERATED_DOCS =
 
+LINT_STYLE ?= mdl_relaxed.rb
+
 serve: setup
 	gitbook serve --port 4040
 
@@ -31,9 +33,9 @@
 	@echo "markdownlint(mdl) version: `mdl --version`"
 	@echo "style config:"
 	@echo "---"
-	@cat mdlstyle.rb
+	@cat $(LINT_STYLE)
 	@echo "---"
-	mdl -s mdlstyle.rb `find -L . ! -path "./partials/*" ! -path "./_book/*" ! -path "./node_modules/*" ! -path "./cord-tester/modules/*" -name "*.md"`
+	mdl -s $(LINT_STYLE) `find -L . ! -path "./partials/*" ! -path "./_book/*" ! -path "./node_modules/*" ! -path "./cord-tester/modules/*" -name "*.md"`
 
 # link directories that contain other documentation
 cord-tester:
diff --git a/charts/helm.md b/charts/helm.md
index 6878791..50bd961 100644
--- a/charts/helm.md
+++ b/charts/helm.md
@@ -16,9 +16,9 @@
 git clone https://gerrit.opencord.org/helm-charts
 ```
 
-> If you have downloaded the CORD code following the
-> [Getting the Source Code](../developer/getting_the_code.md) guide,
-> you'll find it in `~/cord/helm-charts`.
+> If you have downloaded the CORD code following the [Getting the Source
+> Code](../developer/getting_the_code.md) guide, you'll find it in
+> `~/cord/helm-charts`.
 
 ### Add the CORD repository to helm (NOT YET AVAILABLE)
 
diff --git a/developer/workflows.md b/developer/workflows.md
index 44acc4e..1daaf0b 100644
--- a/developer/workflows.md
+++ b/developer/workflows.md
@@ -1,7 +1,7 @@
 # Developer Workflows
 
-This document is intended to describe the workflow to
-develop the control plane of CORD.
+This document is intended to describe the workflow to develop the control plane
+of CORD.
 
 ## Setting up a local development environment
 
@@ -13,10 +13,9 @@
 You can follow this guide to get started with Minikube:
 <https://kubernetes.io/docs/getting-started-guides/minikube/#installation>
 
-> Note: If you are going to do development on Minikube you may want to
->increase it’s memory from the default 512MB,
->you can do that using this command to start Minikube:
->`minikube start --cpus 2 --memory 4096`
+> Note: If you are going to do development on Minikube you may want to increase
+> it’s memory from the default 512MB, you can do that using this command to
+> start Minikube: `minikube start --cpus 2 --memory 4096`
 
 Once Minikube is up and running on your laptop you can proceed with
 the following steps to bring XOS up.
@@ -56,8 +55,8 @@
 We assume that now you have the entire CORD tree under `~/cord`
 
 > Note: to develop a single synchronizer you may not need the full CORD source,
-but this assume  that you have a good knowledge of the system and
-you know what you’re doing.
+> but this assume  that you have a good knowledge of the system and you know
+> what you’re doing.
 
 As first you’ll need to point Docker to the one provided by Minikube
 (_note that you don’t need to have docker installed,
@@ -77,9 +76,9 @@
 At this point the images containing your changes will be available
 in the Docker environment used by Minikube.
 
-> Note: in some cases you can rebuild a single docker image to make
-the process faster, but this assume that you have a good knowledge of the system
-and you know what you’re doing.
+> Note: in some cases you can rebuild a single docker image to make the process
+> faster, but this assume that you have a good knowledge of the system and you
+> know what you’re doing.
 
 All that is left is to teardown and redeploy the containers.
 
@@ -88,15 +87,15 @@
 helm del --purge rcord-lite
 helm install xos-core -n xos-core -f examples/candidate-tag-values.yaml -f examples/if-not-present-values.yaml
 helm dep update xos-profiles/rcord-lite
-helm install xos-profiles/rcord-lite -n rcord-lite -f examples/candidate-tag-values.yaml -f examples/if-not-present-values.yaml
+helm install xos-profiles/rcord-lite -n rcord-lite -f examples/image-tag-candidate.yaml -f examples/imagePullPolicy-IfNotPresent.yaml
 ```
 
 In some cases is possible to use the helm upgrade command,
 but if you made changes to the models we suggest to redeploy everything
 
-> Note: if your changes are only in the synchronizer steps,
-after rebuilding the containers, you can just delete the corresponding POD
-and kubernetes will restart it with the new image
+> Note: if your changes are only in the synchronizer steps, after rebuilding
+> the containers, you can just delete the corresponding POD and kubernetes will
+> restart it with the new image
 
 ## Pushing changes to a remote registry
 
diff --git a/mdlstyle.rb b/mdl_relaxed.rb
similarity index 82%
rename from mdlstyle.rb
rename to mdl_relaxed.rb
index 6504269..9448317 100644
--- a/mdlstyle.rb
+++ b/mdl_relaxed.rb
@@ -12,35 +12,37 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# markdownlint(mdl) style rules
+# markdownlint(mdl) relaxed rules file
+#
 # Rule descriptions:
 #  https://github.com/markdownlint/markdownlint/blob/master/docs/RULES.md
-# Help on writing this rules:
-#. https://github.com/markdownlint/markdownlint/blob/master/docs/creating_styles.md
+# Instructions on modifying the rules file:
+#  https://github.com/markdownlint/markdownlint/blob/master/docs/creating_styles.md
 
 # use all rules
 all
 
+# Exclude rule: Header levels should only increment by one level at a time
+exclude_rule 'MD001'
+
 # Indent lists with 4 spaces
 rule 'MD007', :indent => 4
 
-# Don't enforce line length limitations within code blocks and tables
-rule 'MD013', :code_blocks => false, :tables => false, line_length: false
-
-# Numbered lists should have the correct order
-rule 'MD029', :style => "ordered"
-
-# Allow  ! and ? as trailing punctuation in headers
-rule 'MD026', :punctuation => '.,;:'
-
 # Exclude rule: Trailing spaces
 exclude_rule 'MD009'
 
-# Exclude rule: Fenced code blocks should be surrounded by blank lines
-exclude_rule 'MD031'
+# Don't enforce line length limitations
+exclude_rule 'MD013'
+
+# Allow  ! and ? as trailing punctuation in headers
+rule 'MD026', :punctuation => '.,;:'
 
 # Exclude rule: Multiple spaces after blockquote symbol
 exclude_rule 'MD027'
 
-# Exclude rule: Header levels should only increment by one level at a time
-exclude_rule 'MD001'
\ No newline at end of file
+# Numbered lists should have the correct order
+rule 'MD029', :style => "ordered"
+
+# Exclude rule: Fenced code blocks should be surrounded by blank lines
+exclude_rule 'MD031'
+
diff --git a/mdlstyle.rb b/mdl_strict.rb
similarity index 66%
copy from mdlstyle.rb
copy to mdl_strict.rb
index 6504269..2e02e7c 100644
--- a/mdlstyle.rb
+++ b/mdl_strict.rb
@@ -12,11 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# markdownlint(mdl) style rules
+# markdownlint(mdl) strict rules file
+# To use: `make LINT_STYLE=mdl_strict.rb lint`
+#
 # Rule descriptions:
 #  https://github.com/markdownlint/markdownlint/blob/master/docs/RULES.md
-# Help on writing this rules:
-#. https://github.com/markdownlint/markdownlint/blob/master/docs/creating_styles.md
+# Instructions on modifying the rules file:
+#  https://github.com/markdownlint/markdownlint/blob/master/docs/creating_styles.md
 
 # use all rules
 all
@@ -25,22 +27,11 @@
 rule 'MD007', :indent => 4
 
 # Don't enforce line length limitations within code blocks and tables
-rule 'MD013', :code_blocks => false, :tables => false, line_length: false
-
-# Numbered lists should have the correct order
-rule 'MD029', :style => "ordered"
+rule 'MD013', :code_blocks => false, :tables => false
 
 # Allow  ! and ? as trailing punctuation in headers
 rule 'MD026', :punctuation => '.,;:'
 
-# Exclude rule: Trailing spaces
-exclude_rule 'MD009'
+# Numbered lists should have the correct order
+rule 'MD029', :style => "ordered"
 
-# Exclude rule: Fenced code blocks should be surrounded by blank lines
-exclude_rule 'MD031'
-
-# Exclude rule: Multiple spaces after blockquote symbol
-exclude_rule 'MD027'
-
-# Exclude rule: Header levels should only increment by one level at a time
-exclude_rule 'MD001'
\ No newline at end of file
