diff --git a/exercises/practice/clock/clock.bats b/exercises/practice/clock/clock.bats
index d1ef8471..b6efc3cc 100644
--- a/exercises/practice/clock/clock.bats
+++ b/exercises/practice/clock/clock.bats
@@ -1,7 +1,7 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-11-06T16:26:09+00:00
+# generated on 2026-11-08T06:23:17+00:00
 
 # * The canonical "Compare two clocks for equality" tests
 #   have not been included: for bash they will simply be 
@@ -202,7 +202,7 @@ test_add_minutes_add_across_midnight() { # @test
     assert_output "00:01"
 }
 
-test_add_minutes_add_more_than_one_day_1500_min_25_hrs_() { # @test
+test_add_minutes_add_more_than_one_day_1500_min_25_hrs() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash clock.sh 5 32 + 1500
     assert_success
@@ -258,7 +258,7 @@ test_subtract_minutes_subtract_more_than_two_hours_with_borrow() { # @test
     assert_output "03:35"
 }
 
-test_subtract_minutes_subtract_more_than_one_day_1500_min_25_hrs_() { # @test
+test_subtract_minutes_subtract_more_than_one_day_1500_min_25_hrs() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash clock.sh 5 32 - 1500
     assert_success
diff --git a/exercises/practice/knapsack/knapsack.bats b/exercises/practice/knapsack/knapsack.bats
index 51121be6..3883706f 100644
--- a/exercises/practice/knapsack/knapsack.bats
+++ b/exercises/practice/knapsack/knapsack.bats
@@ -1,7 +1,7 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-11-07T07:50:02+00:00
+# generated on 2026-11-08T06:23:17+00:00
 
 # Usage: knapsack.sh max_wt [items ...]
 # where: items look like "weight:value"
@@ -25,14 +25,14 @@ test_one_item_too_heavy() { # @test
     assert_output "0"
 }
 
-test_five_items_cannot_be_greedy_by_weight_() { # @test
+test_five_items_cannot_be_greedy_by_weight() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash knapsack.sh 10 2:5 2:5 2:5 2:5 10:21
     assert_success
     assert_output "21"
 }
 
-test_five_items_cannot_be_greedy_by_value_() { # @test
+test_five_items_cannot_be_greedy_by_value() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash knapsack.sh 10 2:20 2:20 2:20 2:20 10:50
     assert_success
diff --git a/exercises/practice/ocr-numbers/ocr_numbers.bats b/exercises/practice/ocr-numbers/ocr_numbers.bats
index 4a6663f0..efbd0d70 100644
--- a/exercises/practice/ocr-numbers/ocr_numbers.bats
+++ b/exercises/practice/ocr-numbers/ocr_numbers.bats
@@ -1,7 +1,7 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-11-07T07:50:02+00:00
+# generated on 2026-11-08T06:23:17+00:00
 
 test_recognizes_0() { # @test
     # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
@@ -194,7 +194,7 @@ INPUT
     assert_output "1234567890"
 }
 
-test_numbers_separated_by_empty_lines_are_recognized_lines_are_joined_by_commas_() { # @test
+test_numbers_separated_by_empty_lines_are_recognized_lines_are_joined_by_commas() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash ocr_numbers.sh << INPUT
     _  _ 
diff --git a/exercises/practice/variable-length-quantity/.meta/template.j2 b/exercises/practice/variable-length-quantity/.meta/template.j2
index 4b6d6b11..1ed521e3 100644
--- a/exercises/practice/variable-length-quantity/.meta/template.j2
+++ b/exercises/practice/variable-length-quantity/.meta/template.j2
@@ -5,20 +5,20 @@
 #
 
 {% for case in cases %}
-@test "{{ case["description"] }}" {
+{{ case.test_function_start }}
     {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
     {%- set hex_input = [] %}
-    {%- for num in case["input"]["integers"] %}
+    {%- for num in case.given %}
         {%- set _ = hex_input.append('%02X' % num) %}
     {%- endfor %}
-    run bash {{ solution }} {{ case["property"] }} {{ hex_input | join(" ") }}
-{%- if case["expect_error"] %}
+    run bash {{ solution }} {{ case.property }} {{ hex_input | join(" ") }}
+{%- if case.expect_error %}
     assert_failure
     {#- The error message from the canonical data is not used. #}
     assert_output --partial "incomplete byte sequence"
 {%- else %}
     {%- set hex_output = [] %}
-    {%- for num in case["expected"] %}
+    {%- for num in case.expected %}
         {%- set _ = hex_output.append('%02X' % num) %}
     {%- endfor %}
     assert_success
@@ -27,7 +27,7 @@
 }
 {% endfor %}
 
-@test "invalid subcommand" {
+test_invalid_subcommand() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh hello 80
     assert_failure
diff --git a/exercises/practice/variable-length-quantity/variable_length_quantity.bats b/exercises/practice/variable-length-quantity/variable_length_quantity.bats
index 2da6b2c9..e8394159 100644
--- a/exercises/practice/variable-length-quantity/variable_length_quantity.bats
+++ b/exercises/practice/variable-length-quantity/variable_length_quantity.bats
@@ -1,224 +1,224 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T19:27:37+00:00
+# generated on 2026-11-08T06:49:56+00:00
 
 #
 # *** Input and Output numbers are expressed in hexadecimal.
 #
 
 
-@test "zero" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_zero() { # @test
     # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 00
     assert_success
     assert_output "00"
 }
 
-@test "arbitrary single byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_arbitrary_single_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 40
     assert_success
     assert_output "40"
 }
 
-@test "asymmetric single byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_asymmetric_single_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 53
     assert_success
     assert_output "53"
 }
 
-@test "largest single byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_largest_single_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 7F
     assert_success
     assert_output "7F"
 }
 
-@test "smallest double byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_smallest_double_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 80
     assert_success
     assert_output "81 00"
 }
 
-@test "arbitrary double byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_arbitrary_double_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 2000
     assert_success
     assert_output "C0 00"
 }
 
-@test "asymmetric double byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_asymmetric_double_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode AD
     assert_success
     assert_output "81 2D"
 }
 
-@test "largest double byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_largest_double_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 3FFF
     assert_success
     assert_output "FF 7F"
 }
 
-@test "smallest triple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_smallest_triple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 4000
     assert_success
     assert_output "81 80 00"
 }
 
-@test "arbitrary triple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_arbitrary_triple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 100000
     assert_success
     assert_output "C0 80 00"
 }
 
-@test "asymmetric triple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_asymmetric_triple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 1D59C
     assert_success
     assert_output "87 AB 1C"
 }
 
-@test "largest triple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_largest_triple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 1FFFFF
     assert_success
     assert_output "FF FF 7F"
 }
 
-@test "smallest quadruple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_smallest_quadruple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 200000
     assert_success
     assert_output "81 80 80 00"
 }
 
-@test "arbitrary quadruple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_arbitrary_quadruple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 8000000
     assert_success
     assert_output "C0 80 80 00"
 }
 
-@test "asymmetric quadruple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_asymmetric_quadruple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 357704
     assert_success
     assert_output "81 D5 EE 04"
 }
 
-@test "largest quadruple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_largest_quadruple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode FFFFFFF
     assert_success
     assert_output "FF FF FF 7F"
 }
 
-@test "smallest quintuple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_smallest_quintuple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 10000000
     assert_success
     assert_output "81 80 80 80 00"
 }
 
-@test "arbitrary quintuple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_arbitrary_quintuple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode FF000000
     assert_success
     assert_output "8F F8 80 80 00"
 }
 
-@test "asymmetric quintuple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_asymmetric_quintuple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 86656105
     assert_success
     assert_output "88 B3 95 C2 05"
 }
 
-@test "maximum 32-bit integer input" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_maximum_32_bit_integer_input() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode FFFFFFFF
     assert_success
     assert_output "8F FF FF FF 7F"
 }
 
-@test "two single-byte values" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_two_single_byte_values() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 40 7F
     assert_success
     assert_output "40 7F"
 }
 
-@test "two multi-byte values" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_two_multi_byte_values() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 4000 123456
     assert_success
     assert_output "81 80 00 C8 E8 56"
 }
 
-@test "many multi-byte values" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_many_multi_byte_values() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 2000 123456 FFFFFFF 00 3FFF 4000
     assert_success
     assert_output "C0 00 C8 E8 56 FF FF FF 7F 00 FF 7F 81 80 00"
 }
 
-@test "one byte" {
+test_decode_a_series_of_bytes_producing_a_series_of_integers_one_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh decode 7F
     assert_success
     assert_output "7F"
 }
 
-@test "two bytes" {
+test_decode_a_series_of_bytes_producing_a_series_of_integers_two_bytes() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh decode C0 00
     assert_success
     assert_output "2000"
 }
 
-@test "three bytes" {
+test_decode_a_series_of_bytes_producing_a_series_of_integers_three_bytes() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh decode FF FF 7F
     assert_success
     assert_output "1FFFFF"
 }
 
-@test "four bytes" {
+test_decode_a_series_of_bytes_producing_a_series_of_integers_four_bytes() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh decode 81 80 80 00
     assert_success
     assert_output "200000"
 }
 
-@test "maximum 32-bit integer" {
+test_decode_a_series_of_bytes_producing_a_series_of_integers_maximum_32_bit_integer() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh decode 8F FF FF FF 7F
     assert_success
     assert_output "FFFFFFFF"
 }
 
-@test "incomplete sequence causes error" {
+test_decode_a_series_of_bytes_producing_a_series_of_integers_incomplete_sequence_causes_error() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh decode FF
     assert_failure
     assert_output --partial "incomplete byte sequence"
 }
 
-@test "incomplete sequence causes error, even if value is zero" {
+test_decode_a_series_of_bytes_producing_a_series_of_integers_incomplete_sequence_causes_error_even_if_value_is_zero() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh decode 80
     assert_failure
     assert_output --partial "incomplete byte sequence"
 }
 
-@test "multiple values" {
+test_decode_a_series_of_bytes_producing_a_series_of_integers_multiple_values() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh decode C0 00 C8 E8 56 FF FF FF 7F 00 FF 7F 81 80 00
     assert_success
@@ -226,7 +226,7 @@ load bats-extra
 }
 
 
-@test "invalid subcommand" {
+test_invalid_subcommand() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh hello 80
     assert_failure
diff --git a/exercises/practice/word-count/.meta/template.j2 b/exercises/practice/word-count/.meta/template.j2
index c706f039..a1ea1f27 100644
--- a/exercises/practice/word-count/.meta/template.j2
+++ b/exercises/practice/word-count/.meta/template.j2
@@ -1,20 +1,20 @@
 {{ header }}
 {% for case in cases %}
-@test "{{ case["description"] }}" {
+{{ case.test_function_start }}
     {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-    run bash {{ solution }} "{{ case["input"]["sentence"] }}"
+    run bash {{ solution }} "{{ case.given }}"
     assert_success
-{%- for word, count in case["expected"].items() %}
+{%- for word, count in case.expected.items() %}
     assert_line "{{ word }}: {{ count }}"
 {%- endfor %}
-    assert_equal "${{ "{" }}#lines[@]}" {{ case["expected"] | length }}
+    assert_equal "${{ "{" }}#lines[@]}" {{ case.expected | length }}
 }
 {% endfor %}
 # bash-specific test: Focus the student's attention on the effects of 
 # word splitting and filename expansion:
 # https://www.gnu.org/software/bash/manual/bash.html#Shell-Expansions
 
-@test "contains shell globbing character" {
+test_contains_shell_globbing_character() { $ @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash {{ solution }} "two * words"
     assert_success
diff --git a/exercises/practice/word-count/word_count.bats b/exercises/practice/word-count/word_count.bats
index c0c33586..a8d68074 100644
--- a/exercises/practice/word-count/word_count.bats
+++ b/exercises/practice/word-count/word_count.bats
@@ -1,9 +1,9 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-08-14T05:27:25+00:00
+# generated on 2026-11-08T06:49:56+00:00
 
-@test "count one word" {
+test_count_one_word() { # @test
     # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash word_count.sh "word"
     assert_success
@@ -11,7 +11,7 @@ load bats-extra
     assert_equal "${#lines[@]}" 1
 }
 
-@test "count one of each word" {
+test_count_one_of_each_word() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash word_count.sh "one of each"
     assert_success
@@ -21,7 +21,7 @@ load bats-extra
     assert_equal "${#lines[@]}" 3
 }
 
-@test "multiple occurrences of a word" {
+test_multiple_occurrences_of_a_word() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash word_count.sh "one fish two fish red fish blue fish"
     assert_success
@@ -33,7 +33,7 @@ load bats-extra
     assert_equal "${#lines[@]}" 5
 }
 
-@test "handles cramped lists" {
+test_handles_cramped_lists() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash word_count.sh "one,two,three"
     assert_success
@@ -43,7 +43,7 @@ load bats-extra
     assert_equal "${#lines[@]}" 3
 }
 
-@test "handles expanded lists" {
+test_handles_expanded_lists() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash word_count.sh "one,
 two,
@@ -55,7 +55,7 @@ three"
     assert_equal "${#lines[@]}" 3
 }
 
-@test "ignore punctuation" {
+test_ignore_punctuation() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash word_count.sh "car: carpet as java: javascript!!&@$%^&"
     assert_success
@@ -67,7 +67,7 @@ three"
     assert_equal "${#lines[@]}" 5
 }
 
-@test "include numbers" {
+test_include_numbers() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash word_count.sh "testing, 1, 2 testing"
     assert_success
@@ -77,7 +77,7 @@ three"
     assert_equal "${#lines[@]}" 3
 }
 
-@test "normalize case" {
+test_normalize_case() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash word_count.sh "go Go GO Stop stop"
     assert_success
@@ -86,7 +86,7 @@ three"
     assert_equal "${#lines[@]}" 2
 }
 
-@test "with apostrophes" {
+test_with_apostrophes() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash word_count.sh "'First: don't laugh. Then: don't cry. You're getting it.'"
     assert_success
@@ -101,7 +101,7 @@ three"
     assert_equal "${#lines[@]}" 8
 }
 
-@test "with quotations" {
+test_with_quotations() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash word_count.sh "Joe can't tell between 'large' and large."
     assert_success
@@ -114,7 +114,7 @@ three"
     assert_equal "${#lines[@]}" 6
 }
 
-@test "substrings from the beginning" {
+test_substrings_from_the_beginning() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash word_count.sh "Joe can't tell between app, apple and a."
     assert_success
@@ -129,7 +129,7 @@ three"
     assert_equal "${#lines[@]}" 8
 }
 
-@test "multiple spaces not detected as a word" {
+test_multiple_spaces_not_detected_as_a_word() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash word_count.sh " multiple   whitespaces"
     assert_success
@@ -138,7 +138,7 @@ three"
     assert_equal "${#lines[@]}" 2
 }
 
-@test "alternating word separators not detected as a word" {
+test_alternating_word_separators_not_detected_as_a_word() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash word_count.sh ",
 ,one,
@@ -151,7 +151,7 @@ three"
     assert_equal "${#lines[@]}" 3
 }
 
-@test "quotation for word with apostrophe" {
+test_quotation_for_word_with_apostrophe() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash word_count.sh "can, can't, 'can't'"
     assert_success
@@ -164,7 +164,7 @@ three"
 # word splitting and filename expansion:
 # https://www.gnu.org/software/bash/manual/bash.html#Shell-Expansions
 
-@test "contains shell globbing character" {
+test_contains_shell_globbing_character() { $ @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash word_count.sh "two * words"
     assert_success
diff --git a/exercises/practice/wordy/.meta/template.j2 b/exercises/practice/wordy/.meta/template.j2
index 3f8a0ff7..a7f82b14 100644
--- a/exercises/practice/wordy/.meta/template.j2
+++ b/exercises/practice/wordy/.meta/template.j2
@@ -1,21 +1,21 @@
 {{ header }}
 {% for case in cases %}
-@test "{{ case["description"] }}" {
+{{ case.test_function_start }}
     {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-    run bash {{ solution }} "{{ case["input"]["question"] }}"
-{%- if case["expect_error"] %}
+    run bash {{ solution }} "{{ case.given }}"
+{%- if case.expect_error %}
     assert_failure
-    assert_output "{{ case["expect_error_msg"] }}"
+    assert_output "{{ case.expect_error_msg }}"
 {%- else %}
     assert_success
-    assert_output "{{ case["expected"] }}"
+    assert_output "{{ case.expected }}"
 {%- endif %}
 }
 {% endfor %}
 
 # Track specific tests
 
-@test "strict left to right, ignores typical order of operations" {
+test_strict_left_to_right_ignores_typical_order_of_operations() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash {{ solution }} "What is 2 plus 3 multiplied by 4?"
     assert_success
@@ -23,7 +23,7 @@
     assert_output "20"
 }
 
-@test "reject problem with no operands" {
+test_reject_problem_with_no_operands() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash {{ solution }} "What is plus?"
     assert_failure
diff --git a/exercises/practice/wordy/wordy.bats b/exercises/practice/wordy/wordy.bats
index a6696b91..6ef33e70 100644
--- a/exercises/practice/wordy/wordy.bats
+++ b/exercises/practice/wordy/wordy.bats
@@ -1,191 +1,191 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:25+00:00
+# generated on 2026-11-08T06:49:56+00:00
 
-@test "just a number" {
+test_just_a_number() { # @test
     # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 5?"
     assert_success
     assert_output "5"
 }
 
-@test "just a zero" {
+test_just_a_zero() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 0?"
     assert_success
     assert_output "0"
 }
 
-@test "just a negative number" {
+test_just_a_negative_number() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is -123?"
     assert_success
     assert_output "-123"
 }
 
-@test "addition" {
+test_addition() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 1 plus 1?"
     assert_success
     assert_output "2"
 }
 
-@test "addition with a left hand zero" {
+test_addition_with_a_left_hand_zero() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 0 plus 2?"
     assert_success
     assert_output "2"
 }
 
-@test "addition with a right hand zero" {
+test_addition_with_a_right_hand_zero() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 3 plus 0?"
     assert_success
     assert_output "3"
 }
 
-@test "more addition" {
+test_more_addition() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 53 plus 2?"
     assert_success
     assert_output "55"
 }
 
-@test "addition with negative numbers" {
+test_addition_with_negative_numbers() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is -1 plus -10?"
     assert_success
     assert_output "-11"
 }
 
-@test "large addition" {
+test_large_addition() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 123 plus 45678?"
     assert_success
     assert_output "45801"
 }
 
-@test "subtraction" {
+test_subtraction() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 4 minus -12?"
     assert_success
     assert_output "16"
 }
 
-@test "multiplication" {
+test_multiplication() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is -3 multiplied by 25?"
     assert_success
     assert_output "-75"
 }
 
-@test "division" {
+test_division() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 33 divided by -3?"
     assert_success
     assert_output "-11"
 }
 
-@test "multiple additions" {
+test_multiple_additions() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 1 plus 1 plus 1?"
     assert_success
     assert_output "3"
 }
 
-@test "addition and subtraction" {
+test_addition_and_subtraction() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 1 plus 5 minus -2?"
     assert_success
     assert_output "8"
 }
 
-@test "multiple subtraction" {
+test_multiple_subtraction() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 20 minus 4 minus 13?"
     assert_success
     assert_output "3"
 }
 
-@test "subtraction then addition" {
+test_subtraction_then_addition() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 17 minus 6 plus 3?"
     assert_success
     assert_output "14"
 }
 
-@test "multiple multiplication" {
+test_multiple_multiplication() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 2 multiplied by -2 multiplied by 3?"
     assert_success
     assert_output "-12"
 }
 
-@test "addition and multiplication" {
+test_addition_and_multiplication() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is -3 plus 7 multiplied by -2?"
     assert_success
     assert_output "-8"
 }
 
-@test "multiple division" {
+test_multiple_division() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is -12 divided by 2 divided by -3?"
     assert_success
     assert_output "2"
 }
 
-@test "unknown operation" {
+test_unknown_operation() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 52 cubed?"
     assert_failure
     assert_output "unknown operation"
 }
 
-@test "Non math question" {
+test_non_math_question() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "Who is the President of the United States?"
     assert_failure
     assert_output "unknown operation"
 }
 
-@test "reject problem missing an operand" {
+test_reject_problem_missing_an_operand() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 1 plus?"
     assert_failure
     assert_output "syntax error"
 }
 
-@test "reject problem with no operands or operators" {
+test_reject_problem_with_no_operands_or_operators() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is?"
     assert_failure
     assert_output "syntax error"
 }
 
-@test "reject two operations in a row" {
+test_reject_two_operations_in_a_row() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 1 plus plus 2?"
     assert_failure
     assert_output "syntax error"
 }
 
-@test "reject two numbers in a row" {
+test_reject_two_numbers_in_a_row() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 1 plus 2 1?"
     assert_failure
     assert_output "syntax error"
 }
 
-@test "reject postfix notation" {
+test_reject_postfix_notation() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 1 2 plus?"
     assert_failure
     assert_output "syntax error"
 }
 
-@test "reject prefix notation" {
+test_reject_prefix_notation() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is plus 1 2?"
     assert_failure
@@ -195,7 +195,7 @@ load bats-extra
 
 # Track specific tests
 
-@test "strict left to right, ignores typical order of operations" {
+test_strict_left_to_right_ignores_typical_order_of_operations() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is 2 plus 3 multiplied by 4?"
     assert_success
@@ -203,7 +203,7 @@ load bats-extra
     assert_output "20"
 }
 
-@test "reject problem with no operands" {
+test_reject_problem_with_no_operands() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash wordy.sh "What is plus?"
     assert_failure
diff --git a/exercises/practice/yacht/.meta/template.j2 b/exercises/practice/yacht/.meta/template.j2
index 462873f7..659c1d0b 100644
--- a/exercises/practice/yacht/.meta/template.j2
+++ b/exercises/practice/yacht/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
-@test "{{ case["description"] }}" {
+{{ case.test_function_start }}
     {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-    run bash {{ solution }} "{{ case["input"]["category"] }}" {{ case["input"]["dice"] | join(" ") }}
+    run bash {{ solution }} "{{ case.input.category }}" {{ case.input.dice | join(" ") }}
     assert_success
-    assert_output "{{ case["expected"] }}"
+    assert_output "{{ case.expected }}"
 }
 {% endfor %}
diff --git a/exercises/practice/yacht/yacht.bats b/exercises/practice/yacht/yacht.bats
index 79bdc20b..3dd96e0d 100644
--- a/exercises/practice/yacht/yacht.bats
+++ b/exercises/practice/yacht/yacht.bats
@@ -1,205 +1,205 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T16:53:25+00:00
+# generated on 2026-11-08T06:49:56+00:00
 
-@test "Yacht" {
+test_yacht() { # @test
     # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "yacht" 5 5 5 5 5
     assert_success
     assert_output "50"
 }
 
-@test "Not Yacht" {
+test_not_yacht() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "yacht" 1 3 3 2 5
     assert_success
     assert_output "0"
 }
 
-@test "Ones" {
+test_ones() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "ones" 1 1 1 3 5
     assert_success
     assert_output "3"
 }
 
-@test "Ones, out of order" {
+test_ones_out_of_order() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "ones" 3 1 1 5 1
     assert_success
     assert_output "3"
 }
 
-@test "No ones" {
+test_no_ones() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "ones" 4 3 6 5 5
     assert_success
     assert_output "0"
 }
 
-@test "Twos" {
+test_twos() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "twos" 2 3 4 5 6
     assert_success
     assert_output "2"
 }
 
-@test "Fours" {
+test_fours() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "fours" 1 4 1 4 1
     assert_success
     assert_output "8"
 }
 
-@test "Yacht counted as threes" {
+test_yacht_counted_as_threes() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "threes" 3 3 3 3 3
     assert_success
     assert_output "15"
 }
 
-@test "Yacht of 3s counted as fives" {
+test_yacht_of_3s_counted_as_fives() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "fives" 3 3 3 3 3
     assert_success
     assert_output "0"
 }
 
-@test "Fives" {
+test_fives() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "fives" 1 5 3 5 3
     assert_success
     assert_output "10"
 }
 
-@test "Sixes" {
+test_sixes() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "sixes" 2 3 4 5 6
     assert_success
     assert_output "6"
 }
 
-@test "Full house two small, three big" {
+test_full_house_two_small_three_big() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "full house" 2 2 4 4 4
     assert_success
     assert_output "16"
 }
 
-@test "Full house three small, two big" {
+test_full_house_three_small_two_big() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "full house" 5 3 3 5 3
     assert_success
     assert_output "19"
 }
 
-@test "Two pair is not a full house" {
+test_two_pair_is_not_a_full_house() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "full house" 2 2 4 4 5
     assert_success
     assert_output "0"
 }
 
-@test "Four of a kind is not a full house" {
+test_four_of_a_kind_is_not_a_full_house() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "full house" 1 4 4 4 4
     assert_success
     assert_output "0"
 }
 
-@test "Yacht is not a full house" {
+test_yacht_is_not_a_full_house() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "full house" 2 2 2 2 2
     assert_success
     assert_output "0"
 }
 
-@test "Four of a Kind" {
+test_four_of_a_kind() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "four of a kind" 6 6 4 6 6
     assert_success
     assert_output "24"
 }
 
-@test "Yacht can be scored as Four of a Kind" {
+test_yacht_can_be_scored_as_four_of_a_kind() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "four of a kind" 3 3 3 3 3
     assert_success
     assert_output "12"
 }
 
-@test "Full house is not Four of a Kind" {
+test_full_house_is_not_four_of_a_kind() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "four of a kind" 3 3 3 5 5
     assert_success
     assert_output "0"
 }
 
-@test "Little Straight" {
+test_little_straight() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "little straight" 3 5 4 1 2
     assert_success
     assert_output "30"
 }
 
-@test "Little Straight as Big Straight" {
+test_little_straight_as_big_straight() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "big straight" 1 2 3 4 5
     assert_success
     assert_output "0"
 }
 
-@test "Four in order but not a little straight" {
+test_four_in_order_but_not_a_little_straight() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "little straight" 1 1 2 3 4
     assert_success
     assert_output "0"
 }
 
-@test "No pairs but not a little straight" {
+test_no_pairs_but_not_a_little_straight() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "little straight" 1 2 3 4 6
     assert_success
     assert_output "0"
 }
 
-@test "Minimum is 1, maximum is 5, but not a little straight" {
+test_minimum_is_1_maximum_is_5_but_not_a_little_straight() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "little straight" 1 1 3 4 5
     assert_success
     assert_output "0"
 }
 
-@test "Big Straight" {
+test_big_straight() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "big straight" 4 6 2 5 3
     assert_success
     assert_output "30"
 }
 
-@test "Big Straight as little straight" {
+test_big_straight_as_little_straight() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "little straight" 6 5 4 3 2
     assert_success
     assert_output "0"
 }
 
-@test "No pairs but not a big straight" {
+test_no_pairs_but_not_a_big_straight() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "big straight" 6 5 4 3 1
     assert_success
     assert_output "0"
 }
 
-@test "Choice" {
+test_choice() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "choice" 3 3 5 6 6
     assert_success
     assert_output "23"
 }
 
-@test "Yacht as choice" {
+test_yacht_as_choice() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash yacht.sh "choice" 2 2 2 2 2
     assert_success