diff --git a/README.md b/README.md
index 76ac57a..98cc709 100644
--- a/README.md
+++ b/README.md
@@ -95,6 +95,44 @@ f.TestCases(testCases, func(t *testing.T, f *bdd.Feature, tc testCase) {
 })
 ```
 
+## Simplified template
+
+A simplified template is also available. It uses only the std [testing](https://pkg.go.dev/testing) package without any other dependency. Steps are defined by comments.
+Provide `-template std.simple.v1.go.tmpl` to to use [this](internal/assets/std.simple.v1.go.tmpl) template.
+
+```go
+func TestApplicationCommandLineTool(t *testing.T) {
+	t.Parallel()
+
+	t.Run("User wants to see usage information", func(t *testing.T) {
+		t.Parallel()
+
+		type testCase struct {
+			Flag       string `field:"<flag>"`
+			ExitStatus int    `field:"<exit_status>"`
+			Printed    bool   `field:"<printed>"`
+		}
+
+		testCases := map[string]testCase{
+			"--help_0_true":    {"--help", 0, true},
+			"-help_0_true":     {"-help", 0, true},
+			"-invalid_1_false": {"-invalid", 1, false},
+		}
+
+		for name, tc := range testCases {
+			t.Run(name, func(t *testing.T) {
+				// When flag <flag> is provided
+
+				// Then usage should be printed <printed>
+
+				// And exit status should be <exit_status>
+
+			})
+		}
+	})
+}
+```
+
 ## More advanced example
 
 See [internal/app/app.feature](internal/app/app.feature) and [internal/app/app_test.go](internal/app/app_test.go).
diff --git a/internal/app/app.feature b/internal/app/app.feature
index bca561f..8d1717b 100644
--- a/internal/app/app.feature
+++ b/internal/app/app.feature
@@ -33,6 +33,7 @@ Feature: Application command line tool
     | <feature>   | <template>                      |
     | app.feature | ../assets/std.struct.v1.go.tmpl |
     | app.feature | @/std.struct.v1.go.tmpl         |
+    | app.feature | @/std.simple.v1.go.tmpl         |
   
   Scenario: User wants to set custom package
     When <package> is provided
diff --git a/internal/app/app_test.go b/internal/app/app_test.go
index ffa72d1..ead5203 100644
--- a/internal/app/app_test.go
+++ b/internal/app/app_test.go
@@ -95,6 +95,7 @@ func TestApplicationCommandLineTool(t *testing.T) {
 		testCases := map[string]testCase{
 			"app.feature_../assets/std.struct.v1.go.tmpl": {"app.feature", "../assets/std.struct.v1.go.tmpl"},
 			"app.feature_@/std.struct.v1.go.tmpl":         {"app.feature", "@/std.struct.v1.go.tmpl"},
+			"app.feature_@/std.simple.v1.go.tmpl":         {"app.feature", "@/std.simple.v1.go.tmpl"},
 		}
 
 		f.TestCases(testCases, func(t *testing.T, f *bdd.Feature, tc testCase) {
diff --git a/internal/assets/assets_test.go b/internal/assets/assets_test.go
index ad619eb..043b2f7 100644
--- a/internal/assets/assets_test.go
+++ b/internal/assets/assets_test.go
@@ -24,6 +24,7 @@ func TestOpenTemplate(t *testing.T) {
 
 	files := [...]string{
 		"std.struct.v1.go.tmpl",
+		"std.simple.v1.go.tmpl",
 	}
 
 	for _, f := range files {
diff --git a/internal/assets/std.simple.v1.go.tmpl b/internal/assets/std.simple.v1.go.tmpl
new file mode 100644
index 0000000..8744822
--- /dev/null
+++ b/internal/assets/std.simple.v1.go.tmpl
@@ -0,0 +1,135 @@
+package {{ .PackageName }}
+
+import (
+    "testing"
+)
+
+{{ define "Background" }}
+    {{- $Background := . -}}
+    background := func(t *testing.T) interface{} {
+        {{- range $Background.Steps }}
+        // {{ .Keyword }}{{ .Text }}
+
+        {{ end }}
+
+        return nil // TODO: Feel free to modify return value(s).
+    }
+
+{{ end }}
+
+{{ define "Scenario" }}
+    {{- $Scenario := . -}}
+    t.Run({{ $Scenario.PluginData.GoValue }}, func({{- /*
+        t is usualy unused if there are no examples 
+    */ -}}{{- if and $Scenario.Examples (not $Scenario.PluginData.GoParallel) -}}_{{- else -}}t{{- end -}} *testing.T) {
+        {{- range $Scenario.Examples }}
+        {{- if $Scenario.PluginData.GoParallel }}
+            t.Parallel()
+
+        {{ end -}}
+
+        {{- /* Define test case struct. */ -}}
+
+        type testCase struct {
+            {{- range .TableHeader.Cells }}
+			{{ .PluginData.GoName }} {{ .PluginData.GoType }} `field:"{{.Value}}"`
+            {{- end -}}
+		}
+
+        testCases := map[string]testCase{
+            {{- range .TableBody }}
+			{{ .PluginData.GoValue }}: {
+            {{- /* Struct fields start. */ -}}
+                {{- range $index, $cell := .Cells -}}
+                {{- if $index -}},{{ end }} {{- $cell.PluginData.GoValue -}}
+                {{- end -}}
+            {{- /* Struct fields end. */ -}}
+            },
+            {{- end }}
+		}
+
+        for name, tc := range testCases {
+            {{- if $Scenario.PluginData.GoParallel }}
+            tc := tc
+            {{ end -}}
+
+            t.Run(name, func(t *testing.T) {
+                {{- if $Scenario.PluginData.GoParallel }}
+                t.Parallel()
+
+                {{ end -}}
+                _ = tc // TODO: Use and remove.
+                {{- if $Scenario.PluginData.GoHasBackground }}
+                _ = background(t)
+
+                {{ end -}}
+
+                {{- range $Scenario.Steps }}
+                // {{ .Keyword }}{{ .Text }}
+
+                {{ end }}
+            })
+        }
+        {{- else }}
+        {{- if $Scenario.PluginData.GoParallel }}
+        t.Parallel()
+
+        {{ end -}}
+        {{- if $Scenario.PluginData.GoHasBackground }}
+        _ = background(t)
+
+        {{ end }}
+        {{- range $Scenario.Steps }}
+        // {{ .Keyword }}{{ .Text }}
+
+        {{ end -}}
+        {{ end }}
+    })
+{{ end }}
+
+{{ define "Rule" }}
+    {{ $Rule := . }}
+    t.Run({{ $Rule.PluginData.GoValue }}, func({{- if $Rule.PluginData.GoParallel -}}t{{- else -}}_{{- end -}} *testing.T) {
+        {{- if $Rule.PluginData.GoParallel }}
+            t.Parallel()
+
+        {{ end -}}
+        {{- range $Rule.Children -}}
+
+        {{- if .Background }}
+        {{ template "Background" .Background }}
+        {{- end }}
+
+        {{- if .Scenario }}
+        {{- template "Scenario" .Scenario -}}
+        {{- end }}
+
+        {{- end -}}
+    })
+{{ end }}
+
+func Test{{ .Feature.PluginData.GoName }}(t *testing.T) {
+    {{- if .Feature.PluginData.GoParallel }}
+    t.Parallel()
+
+    {{ end -}}
+    {{ if .Feature.PluginData.GoComment }}
+    /* {{ .Feature.PluginData.GoComment }} */
+    {{ end }}
+
+    {{- range .Feature.Children }}
+
+    {{ if .Background }}
+    {{ template "Background" .Background }}
+    {{- end -}}
+
+    {{ if .Scenario }}
+    {{ template "Scenario" .Scenario }}
+    {{- end -}}
+
+    {{ if .Rule }}
+    {{ template "Rule" .Rule }}
+    {{- end -}}
+
+    {{- end -}}
+}
diff --git a/internal/generator/examples/simple/background.feature_test.go b/internal/generator/examples/simple/background.feature_test.go
new file mode 100644
index 0000000..83cc73b
--- /dev/null
+++ b/internal/generator/examples/simple/background.feature_test.go
@@ -0,0 +1,57 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestMultipleSiteSupport(t *testing.T) {
+	/*
+		Only blog owners can post to a blog, except administrators,
+		who can post to all blogs.
+	*/
+
+	background := func(t *testing.T) interface{} {
+		// Given a global administrator named "Greg"
+
+		// And a blog named "Greg's anti-tax rants"
+
+		// And a customer named "Dr. Bill"
+
+		// And a blog named "Expensive Therapy" owned by "Dr. Bill"
+
+		return nil // TODO: Feel free to modify return value(s).
+	}
+
+	t.Run("Dr. Bill posts to his own blog", func(t *testing.T) {
+		_ = background(t)
+
+		// Given I am logged in as Dr. Bill
+
+		// When I try to post to "Expensive Therapy"
+
+		// Then I should see "Your article was published."
+
+	})
+
+	t.Run("Dr. Bill tries to post to somebody else's blog, and fails", func(t *testing.T) {
+		_ = background(t)
+
+		// Given I am logged in as Dr. Bill
+
+		// When I try to post to "Greg's anti-tax rants"
+
+		// Then I should see "Hey! That's not your blog!"
+
+	})
+
+	t.Run("Greg posts to a client's blog", func(t *testing.T) {
+		_ = background(t)
+
+		// Given I am logged in as Greg
+
+		// When I try to post to "Expensive Therapy"
+
+		// Then I should see "Your article was published."
+
+	})
+}
diff --git a/internal/generator/examples/simple/bool.feature_test.go b/internal/generator/examples/simple/bool.feature_test.go
new file mode 100644
index 0000000..0afc95e
--- /dev/null
+++ b/internal/generator/examples/simple/bool.feature_test.go
@@ -0,0 +1,33 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestTypeDeterminatiopn(t *testing.T) {
+
+	t.Run("All type are determinated", func(_ *testing.T) {
+		type testCase struct {
+			Bool    bool    `field:"<bool>"`
+			Int     int     `field:"<int>"`
+			String  string  `field:"<string>"`
+			Flag    bool    `field:"<flag>"`
+			Float64 float64 `field:"<float64>"`
+		}
+
+		testCases := map[string]testCase{
+			"true_1_hello_-_1.0":  {true, 1, "hello", false, 1.0},
+			"false_2_world_+_0.0": {false, 2, "world", true, 0.0},
+		}
+
+		for name, tc := range testCases {
+			t.Run(name, func(t *testing.T) {
+				_ = tc // TODO: Use and remove.
+				// When generator comleted
+
+				// Then correct types are shown
+
+			})
+		}
+	})
+}
diff --git a/internal/generator/examples/simple/complex.feature_test.go b/internal/generator/examples/simple/complex.feature_test.go
new file mode 100644
index 0000000..29550b8
--- /dev/null
+++ b/internal/generator/examples/simple/complex.feature_test.go
@@ -0,0 +1,48 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestNestedBackground(t *testing.T) {
+
+	background := func(t *testing.T) interface{} {
+		// Given a global administrator named "Greg"
+
+		// And a blog named "Greg's anti-tax rants"
+
+		// And a customer named "Dr. Bill"
+
+		// And a blog named "Expensive Therapy" owned by "Dr. Bill"
+
+		return nil // TODO: Feel free to modify return value(s).
+	}
+
+	t.Run("Dr. Bill posts to his own blog", func(t *testing.T) {
+		_ = background(t)
+
+		// Given I am logged in as Dr. Bill
+
+		// When I try to post to "Expensive Therapy"
+
+		// Then I should see "Your article was published."
+
+	})
+
+	t.Run("There can be only One", func(_ *testing.T) {
+		background := func(t *testing.T) interface{} {
+			// Given I have overdue tasks
+
+			return nil // TODO: Feel free to modify return value(s).
+		}
+
+		t.Run("Only One -- One alive", func(t *testing.T) {
+			_ = background(t)
+
+			// Given there is only 1 ninja alive
+
+			// Then he (or she) will live forever ;-)
+
+		})
+	})
+}
diff --git a/internal/generator/examples/simple/issue_26.feature_test.go b/internal/generator/examples/simple/issue_26.feature_test.go
new file mode 100644
index 0000000..8248cab
--- /dev/null
+++ b/internal/generator/examples/simple/issue_26.feature_test.go
@@ -0,0 +1,24 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestIssueExample(t *testing.T) {
+
+	t.Run("Just a hello world", func(_ *testing.T) {
+		type testCase struct {
+			Name string `field:"<name>"`
+		}
+
+		testCases := map[string]testCase{
+			"hello_world": {"hello world"},
+		}
+
+		for name, tc := range testCases {
+			t.Run(name, func(t *testing.T) {
+				_ = tc // TODO: Use and remove.
+			})
+		}
+	})
+}
diff --git a/internal/generator/examples/simple/issue_27_multi.feature_test.go b/internal/generator/examples/simple/issue_27_multi.feature_test.go
new file mode 100644
index 0000000..0700aa6
--- /dev/null
+++ b/internal/generator/examples/simple/issue_27_multi.feature_test.go
@@ -0,0 +1,20 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestExampleIssue27Multi(t *testing.T) {
+	/*
+		Details:
+		  - example 1
+		  - example 2
+
+		  - example 3
+		    - example 3.1
+		    - example 3.2
+	*/
+
+	t.Run("Multi-line comment with indents", func(t *testing.T) {
+	})
+}
diff --git a/internal/generator/examples/simple/issue_27_single.feature_test.go b/internal/generator/examples/simple/issue_27_single.feature_test.go
new file mode 100644
index 0000000..ec6945b
--- /dev/null
+++ b/internal/generator/examples/simple/issue_27_single.feature_test.go
@@ -0,0 +1,12 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestExampleIssue27Single(t *testing.T) {
+	/* Hello world */
+
+	t.Run("Single comment", func(t *testing.T) {
+	})
+}
diff --git a/internal/generator/examples/simple/readme.feature_test.go b/internal/generator/examples/simple/readme.feature_test.go
new file mode 100644
index 0000000..130c5df
--- /dev/null
+++ b/internal/generator/examples/simple/readme.feature_test.go
@@ -0,0 +1,34 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestApplicationCommandLineTool(t *testing.T) {
+
+	t.Run("User wants to see usage information", func(_ *testing.T) {
+		type testCase struct {
+			Flag       string `field:"<flag>"`
+			ExitStatus int    `field:"<exit_status>"`
+			Printed    bool   `field:"<printed>"`
+		}
+
+		testCases := map[string]testCase{
+			"--help_0_true":    {"--help", 0, true},
+			"-help_0_true":     {"-help", 0, true},
+			"-invalid_1_false": {"-invalid", 1, false},
+		}
+
+		for name, tc := range testCases {
+			t.Run(name, func(t *testing.T) {
+				_ = tc // TODO: Use and remove.
+				// When flag <flag> is provided
+
+				// Then usage should be printed <printed>
+
+				// And exit status should be <exit_status>
+
+			})
+		}
+	})
+}
diff --git a/internal/generator/examples/simple/rules.feature_test.go b/internal/generator/examples/simple/rules.feature_test.go
new file mode 100644
index 0000000..57056f7
--- /dev/null
+++ b/internal/generator/examples/simple/rules.feature_test.go
@@ -0,0 +1,44 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestHighlander(t *testing.T) {
+
+	t.Run("There can be only One", func(_ *testing.T) {
+		background := func(t *testing.T) interface{} {
+			// Given I have overdue tasks
+
+			return nil // TODO: Feel free to modify return value(s).
+		}
+
+		t.Run("Only One -- More than one alive", func(t *testing.T) {
+			_ = background(t)
+
+			// Given there are 3 ninjas
+
+			// And there are more than one ninja alive
+
+			// When 2 ninjas meet, they will fight
+
+			// Then one ninja dies (but not me)
+
+			// And there is one ninja less alive
+
+		})
+		t.Run("Only One -- One alive", func(t *testing.T) {
+			_ = background(t)
+
+			// Given there is only 1 ninja alive
+
+			// Then he (or she) will live forever ;-)
+
+		})
+	})
+
+	t.Run("There can be Two (in some cases)", func(_ *testing.T) {
+		t.Run("Two -- Dead and Reborn as Phoenix", func(t *testing.T) {
+		})
+	})
+}
diff --git a/internal/generator/examples/simple/scenario.feature_test.go b/internal/generator/examples/simple/scenario.feature_test.go
new file mode 100644
index 0000000..0047330
--- /dev/null
+++ b/internal/generator/examples/simple/scenario.feature_test.go
@@ -0,0 +1,30 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestSomeTerseYetDescriptiveTextOfWhatIsDesired(t *testing.T) {
+	/*
+		In order to realize a named business value
+		As an explicit system actor
+		I want to gain some beneficial outcome which furthers the goal
+	*/
+
+	t.Run("Some determinable business situation", func(t *testing.T) {
+		// Given some precondition
+
+		// And some other precondition
+
+		// When some action by the actor
+
+		// And some other action
+
+		// And yet another action
+
+		// Then some testable outcome is achieved
+
+		// And something else we can check happens too
+
+	})
+}
diff --git a/internal/generator/examples/simple/simple.feature_test.go b/internal/generator/examples/simple/simple.feature_test.go
new file mode 100644
index 0000000..ef5b031
--- /dev/null
+++ b/internal/generator/examples/simple/simple.feature_test.go
@@ -0,0 +1,16 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestGuessTheWord(t *testing.T) {
+	/*
+		The word guess game is a turn-based game for two players.
+		The Maker makes a word for the Breaker to guess. The game
+		is over when the Breaker guesses the Maker's word.
+	*/
+
+	t.Run("Maker starts a game", func(t *testing.T) {
+	})
+}
diff --git a/internal/generator/examples/simpleparallel/background.feature_test.go b/internal/generator/examples/simpleparallel/background.feature_test.go
new file mode 100644
index 0000000..2493d02
--- /dev/null
+++ b/internal/generator/examples/simpleparallel/background.feature_test.go
@@ -0,0 +1,65 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestMultipleSiteSupport(t *testing.T) {
+	t.Parallel()
+
+	/*
+		Only blog owners can post to a blog, except administrators,
+		who can post to all blogs.
+	*/
+
+	background := func(t *testing.T) interface{} {
+		// Given a global administrator named "Greg"
+
+		// And a blog named "Greg's anti-tax rants"
+
+		// And a customer named "Dr. Bill"
+
+		// And a blog named "Expensive Therapy" owned by "Dr. Bill"
+
+		return nil // TODO: Feel free to modify return value(s).
+	}
+
+	t.Run("Dr. Bill posts to his own blog", func(t *testing.T) {
+		t.Parallel()
+
+		_ = background(t)
+
+		// Given I am logged in as Dr. Bill
+
+		// When I try to post to "Expensive Therapy"
+
+		// Then I should see "Your article was published."
+
+	})
+
+	t.Run("Dr. Bill tries to post to somebody else's blog, and fails", func(t *testing.T) {
+		t.Parallel()
+
+		_ = background(t)
+
+		// Given I am logged in as Dr. Bill
+
+		// When I try to post to "Greg's anti-tax rants"
+
+		// Then I should see "Hey! That's not your blog!"
+
+	})
+
+	t.Run("Greg posts to a client's blog", func(t *testing.T) {
+		t.Parallel()
+
+		_ = background(t)
+
+		// Given I am logged in as Greg
+
+		// When I try to post to "Expensive Therapy"
+
+		// Then I should see "Your article was published."
+
+	})
+}
diff --git a/internal/generator/examples/simpleparallel/bool.feature_test.go b/internal/generator/examples/simpleparallel/bool.feature_test.go
new file mode 100644
index 0000000..b357cfc
--- /dev/null
+++ b/internal/generator/examples/simpleparallel/bool.feature_test.go
@@ -0,0 +1,39 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestTypeDeterminatiopn(t *testing.T) {
+	t.Parallel()
+
+	t.Run("All type are determinated", func(t *testing.T) {
+		t.Parallel()
+
+		type testCase struct {
+			Bool    bool    `field:"<bool>"`
+			Int     int     `field:"<int>"`
+			String  string  `field:"<string>"`
+			Flag    bool    `field:"<flag>"`
+			Float64 float64 `field:"<float64>"`
+		}
+
+		testCases := map[string]testCase{
+			"true_1_hello_-_1.0":  {true, 1, "hello", false, 1.0},
+			"false_2_world_+_0.0": {false, 2, "world", true, 0.0},
+		}
+
+		for name, tc := range testCases {
+			tc := tc
+			t.Run(name, func(t *testing.T) {
+				t.Parallel()
+
+				_ = tc // TODO: Use and remove.
+				// When generator comleted
+
+				// Then correct types are shown
+
+			})
+		}
+	})
+}
diff --git a/internal/generator/examples/simpleparallel/complex.feature_test.go b/internal/generator/examples/simpleparallel/complex.feature_test.go
new file mode 100644
index 0000000..18081a9
--- /dev/null
+++ b/internal/generator/examples/simpleparallel/complex.feature_test.go
@@ -0,0 +1,55 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestNestedBackground(t *testing.T) {
+	t.Parallel()
+
+	background := func(t *testing.T) interface{} {
+		// Given a global administrator named "Greg"
+
+		// And a blog named "Greg's anti-tax rants"
+
+		// And a customer named "Dr. Bill"
+
+		// And a blog named "Expensive Therapy" owned by "Dr. Bill"
+
+		return nil // TODO: Feel free to modify return value(s).
+	}
+
+	t.Run("Dr. Bill posts to his own blog", func(t *testing.T) {
+		t.Parallel()
+
+		_ = background(t)
+
+		// Given I am logged in as Dr. Bill
+
+		// When I try to post to "Expensive Therapy"
+
+		// Then I should see "Your article was published."
+
+	})
+
+	t.Run("There can be only One", func(t *testing.T) {
+		t.Parallel()
+
+		background := func(t *testing.T) interface{} {
+			// Given I have overdue tasks
+
+			return nil // TODO: Feel free to modify return value(s).
+		}
+
+		t.Run("Only One -- One alive", func(t *testing.T) {
+			t.Parallel()
+
+			_ = background(t)
+
+			// Given there is only 1 ninja alive
+
+			// Then he (or she) will live forever ;-)
+
+		})
+	})
+}
diff --git a/internal/generator/examples/simpleparallel/issue_26.feature_test.go b/internal/generator/examples/simpleparallel/issue_26.feature_test.go
new file mode 100644
index 0000000..c96d874
--- /dev/null
+++ b/internal/generator/examples/simpleparallel/issue_26.feature_test.go
@@ -0,0 +1,30 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestIssueExample(t *testing.T) {
+	t.Parallel()
+
+	t.Run("Just a hello world", func(t *testing.T) {
+		t.Parallel()
+
+		type testCase struct {
+			Name string `field:"<name>"`
+		}
+
+		testCases := map[string]testCase{
+			"hello_world": {"hello world"},
+		}
+
+		for name, tc := range testCases {
+			tc := tc
+			t.Run(name, func(t *testing.T) {
+				t.Parallel()
+
+				_ = tc // TODO: Use and remove.
+			})
+		}
+	})
+}
diff --git a/internal/generator/examples/simpleparallel/issue_27_multi.feature_test.go b/internal/generator/examples/simpleparallel/issue_27_multi.feature_test.go
new file mode 100644
index 0000000..d3277d3
--- /dev/null
+++ b/internal/generator/examples/simpleparallel/issue_27_multi.feature_test.go
@@ -0,0 +1,24 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestExampleIssue27Multi(t *testing.T) {
+	t.Parallel()
+
+	/*
+		Details:
+		  - example 1
+		  - example 2
+
+		  - example 3
+		    - example 3.1
+		    - example 3.2
+	*/
+
+	t.Run("Multi-line comment with indents", func(t *testing.T) {
+		t.Parallel()
+
+	})
+}
diff --git a/internal/generator/examples/simpleparallel/issue_27_single.feature_test.go b/internal/generator/examples/simpleparallel/issue_27_single.feature_test.go
new file mode 100644
index 0000000..3ab8683
--- /dev/null
+++ b/internal/generator/examples/simpleparallel/issue_27_single.feature_test.go
@@ -0,0 +1,16 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestExampleIssue27Single(t *testing.T) {
+	t.Parallel()
+
+	/* Hello world */
+
+	t.Run("Single comment", func(t *testing.T) {
+		t.Parallel()
+
+	})
+}
diff --git a/internal/generator/examples/simpleparallel/readme.feature_test.go b/internal/generator/examples/simpleparallel/readme.feature_test.go
new file mode 100644
index 0000000..f1f14f4
--- /dev/null
+++ b/internal/generator/examples/simpleparallel/readme.feature_test.go
@@ -0,0 +1,40 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestApplicationCommandLineTool(t *testing.T) {
+	t.Parallel()
+
+	t.Run("User wants to see usage information", func(t *testing.T) {
+		t.Parallel()
+
+		type testCase struct {
+			Flag       string `field:"<flag>"`
+			ExitStatus int    `field:"<exit_status>"`
+			Printed    bool   `field:"<printed>"`
+		}
+
+		testCases := map[string]testCase{
+			"--help_0_true":    {"--help", 0, true},
+			"-help_0_true":     {"-help", 0, true},
+			"-invalid_1_false": {"-invalid", 1, false},
+		}
+
+		for name, tc := range testCases {
+			tc := tc
+			t.Run(name, func(t *testing.T) {
+				t.Parallel()
+
+				_ = tc // TODO: Use and remove.
+				// When flag <flag> is provided
+
+				// Then usage should be printed <printed>
+
+				// And exit status should be <exit_status>
+
+			})
+		}
+	})
+}
diff --git a/internal/generator/examples/simpleparallel/rules.feature_test.go b/internal/generator/examples/simpleparallel/rules.feature_test.go
new file mode 100644
index 0000000..ab7d97c
--- /dev/null
+++ b/internal/generator/examples/simpleparallel/rules.feature_test.go
@@ -0,0 +1,55 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestHighlander(t *testing.T) {
+	t.Parallel()
+
+	t.Run("There can be only One", func(t *testing.T) {
+		t.Parallel()
+
+		background := func(t *testing.T) interface{} {
+			// Given I have overdue tasks
+
+			return nil // TODO: Feel free to modify return value(s).
+		}
+
+		t.Run("Only One -- More than one alive", func(t *testing.T) {
+			t.Parallel()
+
+			_ = background(t)
+
+			// Given there are 3 ninjas
+
+			// And there are more than one ninja alive
+
+			// When 2 ninjas meet, they will fight
+
+			// Then one ninja dies (but not me)
+
+			// And there is one ninja less alive
+
+		})
+		t.Run("Only One -- One alive", func(t *testing.T) {
+			t.Parallel()
+
+			_ = background(t)
+
+			// Given there is only 1 ninja alive
+
+			// Then he (or she) will live forever ;-)
+
+		})
+	})
+
+	t.Run("There can be Two (in some cases)", func(t *testing.T) {
+		t.Parallel()
+
+		t.Run("Two -- Dead and Reborn as Phoenix", func(t *testing.T) {
+			t.Parallel()
+
+		})
+	})
+}
diff --git a/internal/generator/examples/simpleparallel/scenario.feature_test.go b/internal/generator/examples/simpleparallel/scenario.feature_test.go
new file mode 100644
index 0000000..4d27f83
--- /dev/null
+++ b/internal/generator/examples/simpleparallel/scenario.feature_test.go
@@ -0,0 +1,34 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestSomeTerseYetDescriptiveTextOfWhatIsDesired(t *testing.T) {
+	t.Parallel()
+
+	/*
+		In order to realize a named business value
+		As an explicit system actor
+		I want to gain some beneficial outcome which furthers the goal
+	*/
+
+	t.Run("Some determinable business situation", func(t *testing.T) {
+		t.Parallel()
+
+		// Given some precondition
+
+		// And some other precondition
+
+		// When some action by the actor
+
+		// And some other action
+
+		// And yet another action
+
+		// Then some testable outcome is achieved
+
+		// And something else we can check happens too
+
+	})
+}
diff --git a/internal/generator/examples/simpleparallel/simple.feature_test.go b/internal/generator/examples/simpleparallel/simple.feature_test.go
new file mode 100644
index 0000000..a56c573
--- /dev/null
+++ b/internal/generator/examples/simpleparallel/simple.feature_test.go
@@ -0,0 +1,20 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestGuessTheWord(t *testing.T) {
+	t.Parallel()
+
+	/*
+		The word guess game is a turn-based game for two players.
+		The Maker makes a word for the Breaker to guess. The game
+		is over when the Breaker guesses the Maker's word.
+	*/
+
+	t.Run("Maker starts a game", func(t *testing.T) {
+		t.Parallel()
+
+	})
+}
diff --git a/scripts/examples.sh b/scripts/examples.sh
index 21db040..a733224 100755
--- a/scripts/examples.sh
+++ b/scripts/examples.sh
@@ -29,4 +29,19 @@ for f in internal/generator/examples/*.feature; do
     -go-parallel \
     $f \
     > ${dir}/parallel/${base}.json
+  go run cmd/gherkingen/main.go \
+    -package examples_test \
+    -permanent-ids \
+    -format go \
+    -go-parallel \
+    -template "@/std.simple.v1.go.tmpl" \
+    $f \
+    > ${dir}/simpleparallel/${base}_test.go
+  go run cmd/gherkingen/main.go \
+    -package examples_test \
+    -permanent-ids \
+    -format go \
+    -template "@/std.simple.v1.go.tmpl" \
+    $f \
+    > ${dir}/simple/${base}_test.go
 done