diff --git a/README.md b/README.md
index c3fe4b3..c40e358 100644
--- a/README.md
+++ b/README.md
@@ -6,18 +6,53 @@
 
 ## 表現の一覧
 
-- "すること\[助詞](不)可能"は冗長な表現です。"すること\[助詞](不)可能"を省き簡潔な表現にすると文章が明瞭になります。
-  - 参考: <http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0>
-- "すること\[助詞]できる"は冗長な表現です。"すること\[助詞]"を省き簡潔な表現にすると文章が明瞭になります。
-  - 参考: <http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0>
-- "であると言えます"は冗長な表現です。"である" または "と言えます"を省き簡潔な表現にすると文章が明瞭になります。
-  - 参考: <http://www.sekaihaasobiba.com/entry/2014/10/24/204024>
-- "であると考えている"は冗長な表現です。"である" または "と考えている"を省き簡潔な表現にすると文章が明瞭になります。
-  - 参考: <http://www.atmarkit.co.jp/ait/articles/1001/19/news106_2.html>
-- "を行う"は冗長な表現です。"する"など簡潔な表現にすると文章が明瞭になります。
-  - 参考: <http://www.atmarkit.co.jp/ait/articles/1001/19/news106_2.html>
-- "を実行"は冗長な表現です。"する"など簡潔な表現にすると文章が明瞭になります。
-  - 参考: <http://www.atmarkit.co.jp/ait/articles/1001/19/news106_2.html>
+### 【dict1】
+
+"すること\[助詞](不)可能"は冗長な表現です。"すること\[助詞](不)可能"を省き簡潔な表現にすると文章が明瞭になります。
+
+- 参考: <http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0>
+
+### 【dict2】
+
+"すること\[助詞]できる"は冗長な表現です。"すること\[助詞]"を省き簡潔な表現にすると文章が明瞭になります。
+
+- 参考: <http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0>
+
+### 【dict3】
+
+"であると言えます"は冗長な表現です。"である" または "と言えます"を省き簡潔な表現にすると文章が明瞭になります。
+
+- 参考: <http://www.sekaihaasobiba.com/entry/2014/10/24/204024>
+
+### 【dict4】
+
+"であると考えている"は冗長な表現です。"である" または "と考えている"を省き簡潔な表現にすると文章が明瞭になります。
+
+- 参考: <http://www.atmarkit.co.jp/ait/articles/1001/19/news106_2.html>
+
+### 【dict5】
+
+"\[サ変名詞]を行う"は冗長な表現です。"\[サ変名詞]する"など簡潔な表現にすると文章が明瞭になります。
+
+[サ変名詞]とは「[名詞]する」というように「する」が後ろについた場合に、動詞の働きをする名詞です。
+
+例）「行動（する）」、「プログラム（する）」
+
+誤検知を防ぐためにデフォルトでは、「[カタナカ]を行う」と「[アルファベット]を行う」は"allows"で無視するように定義されています。
+
+- 参考: <http://www.atmarkit.co.jp/ait/articles/1001/19/news106_2.html>
+
+### 【dict6】
+
+"\[サ変名詞]を実行"は冗長な表現です。"\[サ変名詞]する"など簡潔な表現にすると文章が明瞭になります。
+
+[サ変名詞]とは「[名詞]する」というように「する」が後ろについた場合に、動詞の働きをする名詞です。
+
+例）「行動（する）」、「プログラム（する）」
+
+誤検知を防ぐためにデフォルトでは、「[カタナカ]を実行」と「[アルファベット]を実行」は"allows"で無視するように定義されています。
+
+- 参考: <http://www.atmarkit.co.jp/ait/articles/1001/19/news106_2.html>
 
 ## Install
 
@@ -44,9 +79,42 @@ Via CLI
 ## Options
 
 - `allowNodeTypes`: `string[]`
-    - 無視したいNode typeを配列で指定
-    - Node typeは <https://textlint.github.io/docs/txtnode.html#type> を参照
-    - デフォルトでは、`["BlockQuote", "Link", "ReferenceDef"]`を指定し、引用やリンクのテキストは無視する
+  - 無視したいNode typeを配列で指定
+  - Node typeは <https://textlint.github.io/docs/txtnode.html#type> を参照
+  - デフォルトでは、`["BlockQuote", "Link", "ReferenceDef"]`を指定し、引用やリンクのテキストは無視する
+- `dictOptions`: `object`
+  - それぞれの`dict`に対するオプションを指定する
+  - プロパティに`dict`の【dict[id]】を書き、値には次の辞書オプションを指定する
+- 辞書オプション: `object`
+  - `disbled`: `boolean`
+    - `true`を指定するdictを無効化
+  - `allows`: `string[]`
+    - エラーを無視したいパターンを[正規表現ライクな文字列](https://github.com/textlint/regexp-string-matcher)で指定
+
+例) [dict1](#dict1)は無効化、[dict5](#dict5)で"処理を行う"をエラーにしない。
+
+```json5
+{
+    "rules": {
+        "ja-no-redundant-expression": {
+            "dictOptions": {
+                "dict1": {
+                     "disabled": true
+                },
+                "dict5": {
+                    // "処理を行う" を許可する
+                    allows: [
+                        "/^処理を行う/",
+                        // デフォルトの許可リストは上書きされるので、維持したい場合は追加する
+                        "/^[ァ-ヶ]+を.?行う/",
+                        "/^[a-zA-Z]+を.?行う/"    
+                    ]
+                }
+            }
+        }
+    }
+}
+```
 
 ## Changelog
 
diff --git a/package.json b/package.json
index 8cde8b9..d975894 100644
--- a/package.json
+++ b/package.json
@@ -37,6 +37,7 @@
     "textlint-scripts": "^2.1.0"
   },
   "dependencies": {
+    "@textlint/regexp-string-matcher": "^1.0.2",
     "kuromojin": "^1.3.2",
     "morpheme-match": "^1.2.1",
     "morpheme-match-all": "^1.2.0",
diff --git a/src/dictionary.js b/src/dictionary.js
index d8267ea..9149481 100644
--- a/src/dictionary.js
+++ b/src/dictionary.js
@@ -5,6 +5,9 @@ const punctuations = ["、", "､", "，", ","];
 module.exports = [
     {
         // https://azu.github.io/morpheme-match/?text=省略(することが可能)。
+        id: "dict1",
+        disabled: false,
+        allows: [],
         message: `"する$2$3$4$5$1"は冗長な表現です。"する$2$3$4$5"を省き簡潔な表現にすると文章が明瞭になります。`,
         url: "http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0",
         tokens: [
@@ -29,7 +32,7 @@ module.exports = [
             {
                 pos: "助詞",
                 _capture: "$3",
-                _readme: "\\[助詞]"
+                _readme: "[助詞]"
             },
             {
                 surface_form: punctuations,
@@ -49,6 +52,9 @@ module.exports = [
     },
     {
         // https://azu.github.io/morpheme-match/?text=解析(することができます)。
+        id: "dict2",
+        disabled: false,
+        allows: [],
         message: `"する$4$3$5$1$2"は冗長な表現です。"する$4$3$5"を省き簡潔な表現にすると文章が明瞭になります。`,
         url: "http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0",
         expected: "$3$1$2",
@@ -82,7 +88,7 @@ module.exports = [
                     }
                     return "";
                 },
-                _readme: "\\[助詞]"
+                _readme: "[助詞]"
             },
             {
                 surface_form: punctuations,
@@ -104,6 +110,9 @@ module.exports = [
     },
     {
         // https://azu.github.io/morpheme-match/?text=必要(であると言えます)
+        id: "dict3",
+        disabled: false,
+        allows: [],
         message: `"で$1$6と$5$2ます"は冗長な表現です。"である$6" または "と$5言えます"を省き簡潔な表現にすると文章が明瞭になります。`,
         url: "http://www.sekaihaasobiba.com/entry/2014/10/24/204024",
         tokens: [
@@ -166,6 +175,9 @@ module.exports = [
     },
     {
         // https://azu.github.io/morpheme-match/?text=必要(であると考えている)
+        id: "dict4",
+        disabled: false,
+        allows: [],
         message: `"である$7と$5考えて$6いる"は冗長な表現です。"である$7" または "と$5考えて$6いる"を省き簡潔な表現にすると文章が明瞭になります。`,
         url: "http://www.atmarkit.co.jp/ait/articles/1001/19/news106_2.html",
         expected: "である",
@@ -251,13 +263,23 @@ module.exports = [
     },
     {
         // https://azu.github.io/morpheme-match/?text=動作の(確認を行わなければ)ならない
+        id: "dict5",
+        disabled: false,
+        allows: ["/^[ァ-ヶ]+を.?行う/", "/^[a-zA-Z]+を.?行う/"],
         message: `"$1を$5行う"は冗長な表現です。"$1する"など簡潔な表現にすると文章が明瞭になります。`,
+        description: `[サ変名詞]とは「[名詞]する」というように「する」が後ろについた場合に、動詞の働きをする名詞です。
+
+例）「行動（する）」、「プログラム（する）」
+
+誤検知を防ぐためにデフォルトでは、「[カタカナ]を行う」と「[アルファベット]を行う」は"allows"で無視するように定義されています。
+`,
         url: "http://www.atmarkit.co.jp/ait/articles/1001/19/news106_2.html",
         tokens: [
             {
                 pos: "名詞",
                 pos_detail_1: "サ変接続",
-                _capture: "$1"
+                _capture: "$1",
+                _readme: "[サ変名詞]"
             },
             {
                 surface_form: "を",
@@ -287,13 +309,23 @@ module.exports = [
         ]
     },
     {
+        id: "dict6",
+        disabled: false,
+        allows: ["/^[ァ-ヶ]+を.?実行/", "/^[a-zA-Z]+を.?実行/"],
         message: `"$1を$5実行"は冗長な表現です。"$1する"など簡潔な表現にすると文章が明瞭になります。`,
+        description: `[サ変名詞]とは「[名詞]する」というように「する」が後ろについた場合に、動詞の働きをする名詞です。
+
+例）「行動（する）」、「プログラム（する）」
+
+誤検知を防ぐためにデフォルトでは、「[カタカナ]を実行」と「[アルファベット]を実行」は"allows"で無視するように定義されています。
+`,
         url: "http://www.atmarkit.co.jp/ait/articles/1001/19/news106_2.html",
         tokens: [
             {
                 pos: "名詞",
                 pos_detail_1: "サ変接続",
-                _capture: "$1"
+                _capture: "$1",
+                _readme: "[サ変名詞]"
             },
             {
                 surface_form: "を",
diff --git a/src/index.js b/src/index.js
index ef647db..1f7cb1a 100644
--- a/src/index.js
+++ b/src/index.js
@@ -2,11 +2,19 @@
 "use strict";
 import { wrapReportHandler } from "textlint-rule-helper";
 import StringSource from "textlint-util-to-string";
+import { matchPatterns } from "@textlint/regexp-string-matcher";
 
 const tokenize = require("kuromojin").tokenize;
 const dictionaryList = require("./dictionary");
 const createMatchAll = require("morpheme-match-all");
 
+/**
+ * textの中身をすべて置換する
+ * @param {string} text
+ * @param {string|undefined} from
+ * @param {string} to
+ * @returns {string}
+ */
 const replaceAll = (text, from, to) => {
     return text.split(from).join(to);
 };
@@ -17,6 +25,30 @@ const replaceTokenWith = (matcherToken, actualToken, specialTo) => {
     }
     return actualToken.surface_form;
 };
+
+/**
+ * tokensのsurface_formをつなげた文字列を返す
+ * @param tokens
+ * @returns {string}
+ */
+const tokensToString = tokens => {
+    return tokens.map(token => token.surface_form).join("");
+};
+
+/**
+ * "allows" オプションで許可されているかどうか
+ * @param {*[]} tokens
+ * @param {string[]} allows
+ */
+const isTokensAllowed = (tokens, allows) => {
+    if (allows.length === 0) {
+        return false;
+    }
+    const matchedText = tokensToString(tokens);
+    const allowsMatchResults = matchPatterns(matchedText, allows);
+    return allowsMatchResults.length > 0;
+};
+
 const createExpected = ({ text, matcherTokens, skipped, actualTokens }) => {
     let resultText = text;
     let actualTokenIndex = 0;
@@ -33,7 +65,7 @@ const createExpected = ({ text, matcherTokens, skipped, actualTokens }) => {
     });
     return resultText;
 };
-const createMessage = ({ text, matcherTokens, skipped, actualTokens }) => {
+const createMessage = ({ id, text, matcherTokens, skipped, actualTokens }) => {
     let resultText = text;
     let actualTokenIndex = 0;
     matcherTokens.forEach((token, index) => {
@@ -48,16 +80,25 @@ const createMessage = ({ text, matcherTokens, skipped, actualTokens }) => {
         }
         ++actualTokenIndex;
     });
-    return resultText;
+    return `【${id}】 ${resultText}
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#${id}`;
 };
 
 const reporter = (context, options = {}) => {
     const { Syntax, RuleError, fixer } = context;
     const DefaultOptions = {
         // https://textlint.github.io/docs/txtnode.html#type
-        allowNodeTypes: [Syntax.BlockQuote, Syntax.Link, Syntax.ReferenceDef]
+        allowNodeTypes: [Syntax.BlockQuote, Syntax.Link, Syntax.ReferenceDef],
+        dictOptions: {}
     };
-    const matchAll = createMatchAll(dictionaryList);
+    const dictOptions = options.dictOptions || DefaultOptions.dictOptions;
+    // "disabled": trueな辞書は取り除く
+    const enabledDictionaryList = dictionaryList.filter(dict => {
+        const dictOption = dictOptions[dict.id] || {};
+        const disabled = typeof dictOption.disabled === "boolean" ? dictOption.disabled : dict.disabled;
+        return !disabled;
+    });
+    const matchAll = createMatchAll(enabledDictionaryList);
     const skipNodeTypes = options.allowNodeTypes || DefaultOptions.allowNodeTypes;
     return wrapReportHandler(
         context,
@@ -75,6 +116,14 @@ const reporter = (context, options = {}) => {
                          */
                         const matchResults = matchAll(currentTokens);
                         matchResults.forEach(matchResult => {
+                            const dictOption = dictOptions[matchResult.dict.id] || {};
+                            // "allows" オプションにマッチした場合はエラーを報告しない
+                            const allows = dictOption.allows || matchResult.dict.allows;
+                            const isAllowed = isTokensAllowed(matchResult.tokens, allows);
+                            if (isAllowed) {
+                                return;
+                            }
+                            // エラー報告
                             const firstToken = matchResult.tokens[0];
                             const lastToken = matchResult.tokens[matchResult.tokens.length - 1];
                             const firstWordIndex = source.originalIndexFromIndex(
@@ -86,11 +135,12 @@ const reporter = (context, options = {}) => {
                             // replace $1
                             const message =
                                 createMessage({
+                                    id: matchResult.dict.id,
                                     text: matchResult.dict.message,
                                     matcherTokens: matchResult.dict.tokens,
                                     skipped: matchResult.skipped,
                                     actualTokens: matchResult.tokens
-                                }) + (matchResult.dict.url ? `参考: ${matchResult.dict.url}` : "");
+                                });
                             const expected = matchResult.dict.expected
                                              ? createExpected({
                                     text: matchResult.dict.expected,
diff --git a/test/dictionary-test.js b/test/dictionary-test.js
new file mode 100644
index 0000000..306a108
--- /dev/null
+++ b/test/dictionary-test.js
@@ -0,0 +1,26 @@
+// MIT © 2019 azu
+"use strict";
+import assert from "assert";
+
+describe('dictionary', function() {
+    it("should not have duplicated id", () => {
+        const dictionary = require("../src/dictionary.js");
+        dictionary.forEach(item => {
+            assert.ok(typeof item.id === "string", "should have id property");
+            const sameIdItems = dictionary.filter(target => target.id === item.id);
+            assert.ok(sameIdItems.length === 1, "should not have duplicated id item");
+        });
+    });
+    it("should have disabled default value", () => {
+        const dictionary = require("../src/dictionary.js");
+        dictionary.forEach(item => {
+            assert.ok(typeof item.disabled === "boolean", `${item} should have disabled property`);
+        });
+    });
+    it("should have allows default value", () => {
+        const dictionary = require("../src/dictionary.js");
+        dictionary.forEach(item => {
+            assert.ok(Array.isArray(item.allows), `${item}: should have disabled property`);
+        });
+    });
+});
diff --git a/test/index-test.js b/test/index-test.js
index 1f19ed5..f8ab7c9 100644
--- a/test/index-test.js
+++ b/test/index-test.js
@@ -16,7 +16,31 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
 1. 省略する
 2. ことが可能
 3. リストはアイテムごとにチェックする
-`
+`,
+        // デフォルトの例外
+        "プログラムを実行する",
+        "テストを行う",
+        {
+            text: "処理を行う",
+            options: {
+                dictOptions: {
+                    "dict5": {
+                        allows: ["処理"]
+                    }
+                }
+            }
+        },
+        {
+            // 辞書を無効化しているのでマッチしない
+            text: "これは省略することが可能だが、省略しない。",
+            options: {
+                dictOptions: {
+                    "dict1": {
+                        disabled: true
+                    }
+                }
+            }
+        }
     ],
     invalid: [
         // option
@@ -28,17 +52,37 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             },
             errors: [
                 {
-                    message: `"することが可能だ"は冗長な表現です。"することが可能"を省き簡潔な表現にすると文章が明瞭になります。参考: http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0`,
+                    message: `【dict1】 "することが可能だ"は冗長な表現です。"することが可能"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict1`,
                     index: 7
                 }
             ]
         },
+        {
+            // disable allows
+            text: "テストを行う",
+            options: {
+                dictOptions: {
+                    "dict5": {
+                        allows: []
+                    }
+                }
+            },
+            errors: [
+                {
+                    message: `【dict5】 "テストを行う"は冗長な表現です。"テストする"など簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict5`,
+                    index: 0
+                }
+            ]
+        },
         // code + str
         {
             text: "`code`は省略することが可能だが、省略しない。",
             errors: [
                 {
-                    message: `"することが可能だ"は冗長な表現です。"することが可能"を省き簡潔な表現にすると文章が明瞭になります。参考: http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0`,
+                    message: `【dict1】 "することが可能だ"は冗長な表現です。"することが可能"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict1`,
                     index: 9
                 }
             ]
@@ -48,7 +92,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             text: "これは省略することが可能だが、省略しない。",
             errors: [
                 {
-                    message: `"することが可能だ"は冗長な表現です。"することが可能"を省き簡潔な表現にすると文章が明瞭になります。参考: http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0`,
+                    message: `【dict1】 "することが可能だ"は冗長な表現です。"することが可能"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict1`,
                     index: 5
                 }
             ]
@@ -57,7 +102,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             text: "これは省略することが可能です。",
             errors: [
                 {
-                    message: `"することが可能です"は冗長な表現です。"することが可能"を省き簡潔な表現にすると文章が明瞭になります。参考: http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0`,
+                    message: `【dict1】 "することが可能です"は冗長な表現です。"することが可能"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict1`,
                     index: 5
                 }
             ]
@@ -66,7 +112,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             text: "これは省略することも可能だ。",
             errors: [
                 {
-                    message: `"することも可能だ"は冗長な表現です。"することも可能"を省き簡潔な表現にすると文章が明瞭になります。参考: http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0`,
+                    message: `【dict1】 "することも可能だ"は冗長な表現です。"することも可能"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict1`,
                     index: 5
                 }
             ]
@@ -75,7 +122,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             text: "これは省略する事は可能だ。",
             errors: [
                 {
-                    message: `"する事は可能だ"は冗長な表現です。"する事は可能"を省き簡潔な表現にすると文章が明瞭になります。参考: http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0`,
+                    message: `【dict1】 "する事は可能だ"は冗長な表現です。"する事は可能"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict1`,
                     index: 5
                 }
             ]
@@ -84,7 +132,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             text: "これは省略することは，可能だ。",
             errors: [
                 {
-                    message: `"することは，可能だ"は冗長な表現です。"することは，可能"を省き簡潔な表現にすると文章が明瞭になります。参考: http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0`,
+                    message: `【dict1】 "することは，可能だ"は冗長な表現です。"することは，可能"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict1`,
                     index: 5
                 }
             ]
@@ -93,7 +142,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             text: "これは省略することは可能だ。",
             errors: [
                 {
-                    message: `"することは可能だ"は冗長な表現です。"することは可能"を省き簡潔な表現にすると文章が明瞭になります。参考: http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0`,
+                    message: `【dict1】 "することは可能だ"は冗長な表現です。"することは可能"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict1`,
                     index: 5
                 }
             ]
@@ -102,7 +152,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             text: "これは省略することは不可能だ。",
             errors: [
                 {
-                    message: `"することは不可能だ"は冗長な表現です。"することは不可能"を省き簡潔な表現にすると文章が明瞭になります。参考: http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0`,
+                    message: `【dict1】 "することは不可能だ"は冗長な表現です。"することは不可能"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict1`,
                     index: 5
                 }
             ]
@@ -112,7 +163,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             output: "必要なら解析できます。",
             errors: [
                 {
-                    message: `"することができます"は冗長な表現です。"することが"を省き簡潔な表現にすると文章が明瞭になります。参考: http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0`,
+                    message: `【dict2】 "することができます"は冗長な表現です。"することが"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict2`,
                     index: 6
                 }
             ]
@@ -122,7 +174,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             output: "必要なら解析できます。",
             errors: [
                 {
-                    message: `"することが、できます"は冗長な表現です。"することが、"を省き簡潔な表現にすると文章が明瞭になります。参考: http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0`,
+                    message: `【dict2】 "することが、できます"は冗長な表現です。"することが、"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict2`,
                     index: 6
                 }
             ]
@@ -132,7 +185,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             output: "必要なら解析できます。",
             errors: [
                 {
-                    message: `"することが,できます"は冗長な表現です。"することが,"を省き簡潔な表現にすると文章が明瞭になります。参考: http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0`,
+                    message: `【dict2】 "することが,できます"は冗長な表現です。"することが,"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict2`,
                     index: 6
                 }
             ]
@@ -142,7 +196,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             output: "解析もできますよ。",
             errors: [
                 {
-                    message: `"することもできます"は冗長な表現です。"することも"を省き簡潔な表現にすると文章が明瞭になります。参考: http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0`,
+                    message: `【dict2】 "することもできます"は冗長な表現です。"することも"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict2`,
                     index: 2
                 }
             ]
@@ -152,7 +207,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             output: "解析はできますよ。",
             errors: [
                 {
-                    message: `"することはできます"は冗長な表現です。"することは"を省き簡潔な表現にすると文章が明瞭になります。参考: http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0`,
+                    message: `【dict2】 "することはできます"は冗長な表現です。"することは"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict2`,
                     index: 2
                 }
             ]
@@ -162,7 +218,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             output: "解析はできますよ。",
             errors: [
                 {
-                    message: `"する事はできます"は冗長な表現です。"する事は"を省き簡潔な表現にすると文章が明瞭になります。参考: http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0`,
+                    message: `【dict2】 "する事はできます"は冗長な表現です。"する事は"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict2`,
                     index: 2
                 }
             ]
@@ -173,7 +230,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             output: "解析できますよ。",
             errors: [
                 {
-                    message: `"することをできます"は冗長な表現です。"することを"を省き簡潔な表現にすると文章が明瞭になります。参考: http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0`,
+                    message: `【dict2】 "することをできます"は冗長な表現です。"することを"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict2`,
                     index: 2
                 }
             ]
@@ -182,7 +240,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             text: "これは必要であると言えます。",
             errors: [
                 {
-                    message: `"であると言えます"は冗長な表現です。"である" または "と言えます"を省き簡潔な表現にすると文章が明瞭になります。参考: http://www.sekaihaasobiba.com/entry/2014/10/24/204024`,
+                    message: `【dict3】 "であると言えます"は冗長な表現です。"である" または "と言えます"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict3`,
                     index: 5
                 }
             ]
@@ -191,7 +250,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             text: "これは必要であると、言えます。",
             errors: [
                 {
-                    message: `"であると、言えます"は冗長な表現です。"である" または "と、言えます"を省き簡潔な表現にすると文章が明瞭になります。参考: http://www.sekaihaasobiba.com/entry/2014/10/24/204024`,
+                    message: `【dict3】 "であると、言えます"は冗長な表現です。"である" または "と、言えます"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict3`,
                     index: 5
                 }
             ]
@@ -201,7 +261,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             output: `これは大切である`,
             errors: [
                 {
-                    message: `"であると考えている"は冗長な表現です。"である" または "と考えている"を省き簡潔な表現にすると文章が明瞭になります。参考: http://www.atmarkit.co.jp/ait/articles/1001/19/news106_2.html`,
+                    message: `【dict4】 "であると考えている"は冗長な表現です。"である" または "と考えている"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict4`,
                     index: 5
                 }
             ]
@@ -210,7 +271,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             text: "これは必要で有るといえます。",
             errors: [
                 {
-                    message: `"で有るといえます"は冗長な表現です。"である" または "と言えます"を省き簡潔な表現にすると文章が明瞭になります。参考: http://www.sekaihaasobiba.com/entry/2014/10/24/204024`,
+                    message: `【dict3】 "で有るといえます"は冗長な表現です。"である" または "と言えます"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict3`,
                     index: 5
                 }
             ]
@@ -219,7 +281,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             text: "これは必要である,と、考えて,います。",
             errors: [
                 {
-                    message: `"である,と、考えて,いる"は冗長な表現です。"である," または "と、考えて,いる"を省き簡潔な表現にすると文章が明瞭になります。参考: http://www.atmarkit.co.jp/ait/articles/1001/19/news106_2.html`,
+                    message: `【dict4】 "である,と、考えて,いる"は冗長な表現です。"である," または "と、考えて,いる"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict4`,
                     index: 5
                 }
             ]
@@ -228,7 +291,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             text: "実験を行えば分かります。",
             errors: [
                 {
-                    message: `"実験を行う"は冗長な表現です。"実験する"など簡潔な表現にすると文章が明瞭になります。参考: http://www.atmarkit.co.jp/ait/articles/1001/19/news106_2.html`,
+                    message: `【dict5】 "実験を行う"は冗長な表現です。"実験する"など簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict5`,
                     index: 0
                 }
             ]
@@ -237,7 +301,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             text: "実験を,行えば分かります。",
             errors: [
                 {
-                    message: `"実験を,行う"は冗長な表現です。"実験する"など簡潔な表現にすると文章が明瞭になります。参考: http://www.atmarkit.co.jp/ait/articles/1001/19/news106_2.html`,
+                    message: `【dict5】 "実験を,行う"は冗長な表現です。"実験する"など簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict5`,
                     index: 0
                 }
             ]
@@ -246,7 +311,8 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
             text: "検査を実行すれば分かります。",
             errors: [
                 {
-                    message: `"検査を実行"は冗長な表現です。"検査する"など簡潔な表現にすると文章が明瞭になります。参考: http://www.atmarkit.co.jp/ait/articles/1001/19/news106_2.html`,
+                    message: `【dict6】 "検査を実行"は冗長な表現です。"検査する"など簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict6`,
                     index: 0
                 }
             ]
@@ -258,17 +324,20 @@ tester.run("textlint-rule-ja-no-redundant-expression", rule, {
                 "このコマンドの後には任意の値を設定することができる。このため、設定した値ごとに、システムの動作の確認を行わなければならない。この作業には時間がかかるため、テスト要員の追加が必要であると考えている。",
             errors: [
                 {
-                    message: `"することができる。"は冗長な表現です。"することが"を省き簡潔な表現にすると文章が明瞭になります。参考: http://qiita.com/takahi-i/items/a93dc2ff42af6b93f6e0`,
+                    message: `【dict2】 "することができる。"は冗長な表現です。"することが"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict2`,
                     line: 1,
                     column: 18
                 },
                 {
-                    message: `"確認を行う"は冗長な表現です。"確認する"など簡潔な表現にすると文章が明瞭になります。参考: http://www.atmarkit.co.jp/ait/articles/1001/19/news106_2.html`,
+                    message: `【dict5】 "確認を行う"は冗長な表現です。"確認する"など簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict5`,
                     line: 1,
                     column: 49
                 },
                 {
-                    message: `"であると考えている"は冗長な表現です。"である" または "と考えている"を省き簡潔な表現にすると文章が明瞭になります。参考: http://www.atmarkit.co.jp/ait/articles/1001/19/news106_2.html`,
+                    message: `【dict4】 "であると考えている"は冗長な表現です。"である" または "と考えている"を省き簡潔な表現にすると文章が明瞭になります。
+解説: https://github.com/textlint-ja/textlint-rule-ja-no-redundant-expression#dict4`,
                     line: 1,
                     column: 89
                 }
diff --git a/tools/update-readme.js b/tools/update-readme.js
index b7cda11..d0d23f7 100644
--- a/tools/update-readme.js
+++ b/tools/update-readme.js
@@ -5,6 +5,18 @@ const path = require("path");
 const dict = require("../src/dictionary");
 const addMarkdown = require("add-text-to-markdown");
 const SectionName = "表現の一覧";
+const escapeMarkdown = (text) => {
+    return text.replace(/([\[])/g, "\\$1");
+};
+
+/**
+ * descriptionがある場合はその内容を返す
+ * descriptionはgitの3行目と同じように詳細な解説内容
+ * @param dict
+ */
+const createDescription = (dict) => {
+    return dict.description ? `\n\n${dict.description}` : ""
+};
 const replaceWithCaptureTokens = (text, tokens) => {
     let resultText = text;
     tokens.forEach(token => {
@@ -13,9 +25,9 @@ const replaceWithCaptureTokens = (text, tokens) => {
             return;
         }
         if (token._readme) {
-            resultText = resultText.split(token._capture).join(token._readme);
+            resultText = resultText.split(token._capture).join(escapeMarkdown(token._readme));
         } else if (token.basic_form) {
-            resultText = resultText.split(token._capture).join(token.basic_form);
+            resultText = resultText.split(token._capture).join(escapeMarkdown(token.basic_form));
         } else {
             resultText = resultText.split(token._capture).join("");
         }
@@ -26,11 +38,14 @@ const createExamples = dictionaries => {
     return dictionaries
         .map(dict => {
             return (
-                `- ${replaceWithCaptureTokens(dict.message, dict.tokens)}` +
+                `### 【${dict.id}】
+
+${replaceWithCaptureTokens(dict.message, dict.tokens)}${createDescription(dict)}` +
                 (dict.url
-                    ? `
-  - 参考: ${dict.url}`
-                    : "")
+                 ? `
+- 参考: ${dict.url}
+`
+                 : "")
             );
         })
         .join("\n");
diff --git a/yarn.lock b/yarn.lock
index 7cd2048..acfddaf 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -729,6 +729,18 @@
     traverse "^0.6.6"
     unified "^6.1.6"
 
+"@textlint/regexp-string-matcher@^1.0.2":
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/@textlint/regexp-string-matcher/-/regexp-string-matcher-1.0.2.tgz#af2f04023d1481e1e6144f8ef22788811b93e542"
+  integrity sha512-AU4QVhTgdVOC+YdwpJdRTuSSl/bnxxKy/ou0UnuGOK8Phlq5K0zDOsLnBur55xRYf0wW8mYvb3YiiTxJDdPGhQ==
+  dependencies:
+    escape-string-regexp "^1.0.5"
+    execall "^1.0.0"
+    lodash.sortby "^4.7.0"
+    lodash.uniq "^4.5.0"
+    lodash.uniqwith "^4.5.0"
+    to-regex "^3.0.2"
+
 "@textlint/text-to-ast@^3.1.2":
   version "3.1.2"
   resolved "https://registry.npmjs.org/@textlint/text-to-ast/-/text-to-ast-3.1.2.tgz#aa1d3058d625f647b35a9f2c1124457d51ec44a9"
@@ -1134,6 +1146,14 @@ cli-truncate@^0.2.1:
     slice-ansi "0.0.4"
     string-width "^1.0.1"
 
+clone-regexp@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/clone-regexp/-/clone-regexp-1.0.1.tgz#051805cd33173375d82118fc0918606da39fd60f"
+  integrity sha512-Fcij9IwRW27XedRIJnSOEupS7RVcXtObJXbcUOX93UCLqqOdRpkvzKywOOSizmEK/Is3S/RHX9dLdfo6R1Q1mw==
+  dependencies:
+    is-regexp "^1.0.0"
+    is-supported-regexp-flag "^1.0.0"
+
 co@^4.6.0:
   version "4.6.0"
   resolved "https://registry.yarnpkg.com/co/-/co-4.6.0.tgz#6ea6bdf3d853ae54ccb8e47bfa0bf3f9031fb184"
@@ -1474,6 +1494,13 @@ execa@^1.0.0:
     signal-exit "^3.0.0"
     strip-eof "^1.0.0"
 
+execall@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/execall/-/execall-1.0.0.tgz#73d0904e395b3cab0658b08d09ec25307f29bb73"
+  integrity sha1-c9CQTjlbPKsGWLCNCewlMH8pu3M=
+  dependencies:
+    clone-regexp "^1.0.0"
+
 expand-brackets@^2.1.4:
   version "2.1.4"
   resolved "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz#b77735e315ce30f6b6eff0f83b04151a22449622"
@@ -2148,6 +2175,11 @@ is-stream@^1.1.0:
   resolved "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44"
   integrity sha1-EtSj3U5o4Lec6428hBc66A2RykQ=
 
+is-supported-regexp-flag@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/is-supported-regexp-flag/-/is-supported-regexp-flag-1.0.1.tgz#21ee16518d2c1dd3edd3e9a0d57e50207ac364ca"
+  integrity sha512-3vcJecUUrpgCqc/ca0aWeNu64UGgxcvO60K/Fkr1N6RSvfGCTU60UKN68JDmKokgba0rFFJs12EnzOQa14ubKQ==
+
 is-symbol@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.0.1.tgz#3cc59f00025194b6ab2e38dbae6689256b660572"
@@ -2435,6 +2467,21 @@ lodash.debounce@^4.0.8:
   resolved "https://registry.npmjs.org/lodash.debounce/-/lodash.debounce-4.0.8.tgz#82d79bff30a67c4005ffd5e2515300ad9ca4d7af"
   integrity sha1-gteb/zCmfEAF/9XiUVMArZyk168=
 
+lodash.sortby@^4.7.0:
+  version "4.7.0"
+  resolved "https://registry.npmjs.org/lodash.sortby/-/lodash.sortby-4.7.0.tgz#edd14c824e2cc9c1e0b0a1b42bb5210516a42438"
+  integrity sha1-7dFMgk4sycHgsKG0K7UhBRakJDg=
+
+lodash.uniq@^4.5.0:
+  version "4.5.0"
+  resolved "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz#d0225373aeb652adc1bc82e4945339a842754773"
+  integrity sha1-0CJTc662Uq3BvILklFM5qEJ1R3M=
+
+lodash.uniqwith@^4.5.0:
+  version "4.5.0"
+  resolved "https://registry.npmjs.org/lodash.uniqwith/-/lodash.uniqwith-4.5.0.tgz#7a0cbf65f43b5928625a9d4d0dc54b18cadc7ef3"
+  integrity sha1-egy/ZfQ7WShiWp1NDcVLGMrcfvM=
+
 lodash@^4.0.0, lodash@^4.14.0:
   version "4.17.4"
   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.4.tgz#78203a4d1c328ae1d86dca6460e369b57f4055ae"