> For AI agents: the complete documentation index is available at /Practical-Introduction-to-Spring-Boot/llms.txt, the full documentation bundle is available at /Practical-Introduction-to-Spring-Boot/llms-full.txt.

# おまじないから始める AI 駆動型 TDD 入門

## 講義の区切り

本編の目安は30分です。終了条件は「AI に TDD を実践させるメリットと、実践したか確認するポイントを説明できること」です。
Java のコードを動かす環境がなくても、本編は読み進められます。
実際に試したい方は、[付録の送料計算演習](#付録送料計算で-tdd-を試す) に取り組んでください。演習は別途60〜90分が目安です。
前後の章は [学習ガイド](/Practical-Introduction-to-Spring-Boot/introduction.md) で確認できます。

## これだけ覚えて帰ってください

Kiro でタスク一覧を生成する際に、プロンプトの末尾に次の文言を追加してみてください。
ほかの AI コーディング支援ツールでも、実装を依頼するときに使えます。

> t_wada の TDD に則り、
> Red → Green → Refactoring のサイクルを短く回し、
> コミットしていってください。

この指示で、動くだけでなく、保守しやすいコードを作ることを目指します。
なぜ、この「おまじない」が役立つのでしょうか。

## おまじない

冒頭の一文は、和田卓人さん（t_wada 氏）が紹介する TDD の進め方で実装するよう、AI に依頼しています。
TDD は Test-Driven Development（テスト駆動開発）の略です。

期待する動作をテストにし、失敗を確認してから実装し、動作を保って構造を整えます。
和田さんによる [Kent Beck「テスト駆動開発の定義」の翻訳と解説](https://t-wada.hatenablog.jp/entry/canon-tdd-by-kent-beck) でも、この流れが説明されています。

冒頭の一文は本教材のプロンプト例であり、和田さんの発言の引用ではありません。
人名を含めるだけで品質が保証されるわけではありません。

## おまじないの正体

AI が突然、賢くなるわけではありません。
AI に「何を作るか」だけでなく、**「どう作るか」を指定している**ことがポイントです。

完成したコードを最後に確認するだけでなく、開発の途中に検証と見直しを組み込みます。
いわゆる「プロセスで品質を作り込む」という考え方です。
手順を定め、実践し、結果を見て改善する点に注目すると、TDD の狙いを理解しやすくなります。

ここでは、AI が編集とテスト実行を進め、人間が仕様・差分・実行結果を確認する開発を「AI 駆動型」と呼びます。
では、TDD ではどのような手順でコードを作るのでしょうか。

## TDD の小さな一周

まず、期待する動作をテストリストにまとめ、次に実現する振る舞いを1つ選びます。
すべてのテストコードを先に書く必要はありません。

1. **Red**：テストを書き、意図した理由で失敗するか確かめる
2. **Green**：そのテストを通すために必要な実装をする
3. **Refactoring**：動作を保ち、必要なら構造を整える

既存のテストも含めて実行し、差分を確認してコミットしたら、次の振る舞いへ進みます。
「短く回す」とは、一度に扱う振る舞いを絞って進めることです。
コミットは、変更を見返したり戻したりするために、この教材で加えている運用上の区切りです。

以降は「送料は通常500円、商品合計が3,000円以上なら無料」という機能を例に、各段階を見ていきます。
コードとログは説明用の抜粋です。実行する場合の設定と完全なコードは付録にあります。

## TDD のプロセス - Red

最初に「商品合計が1,000円なら送料は500円」という振る舞いを、テストにします。
次はテストメソッドの本体の抜粋です。

```java
var calculator = new ShippingFeeCalculator();
assertEquals(500, calculator.calculate(1000));
```

対象のメソッドが仮に `return 0;` なら、次のように失敗します。

```text
expected: <500> but was: <0>
Tests run: 1, Failures: 1, Errors: 0, Skipped: 0
```

確認するのは、**意図した未実装の振る舞いを、テストが検出できたか**です。
クラスが存在しないためのコンパイルエラーや、依存関係の取得失敗とは区別します。
この例では、骨組みを用意したうえで、期待値500と実際の値0の不一致を確認します。

## TDD のプロセス - Green

今のテストを通すために必要な実装をします。

```java
public int calculate(int subtotal) {
  return 500;
}
```

```text
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
```

今の1件には十分ですが、送料計算全体はまだ完成していません。
次の一周で「3,000円なら送料は0円」というテストを追加し、失敗を確認してから条件分岐を実装します。
固定値から始めるのは、歩幅を小さくするための選択です。毎回必須の手順ではありません。

Green では、新しいテストだけでなく、それまでに書いたテストも成功することを確認します。

## TDD のプロセス - Refactoring

テストが通ったら、動作を保ったまま読みやすさや構造を見直します。
たとえば、送料無料の条件を実装した後に、金額の意味を定数名で表します。

```java
private static final int STANDARD_SHIPPING_FEE = 500;
private static final int FREE_SHIPPING_THRESHOLD = 3000;

public int calculate(int subtotal) {
  if (subtotal >= FREE_SHIPPING_THRESHOLD) {
    return 0;
  }
  return STANDARD_SHIPPING_FEE;
}
```

テストの期待値は変えず、変更の前後で既存テストをすべて実行します。
送料無料の条件を追加するのは機能追加、計算結果を保って定数名で意味を表すのはリファクタリングです。

改善が必要なければ、そのまま次へ進んで構いません。
整理した場合は再実行し、差分を確認して、テストが通った状態をコミットします。

## AI 駆動開発で TDD を実践するメリット（1/2）

- **AI に客観的な合否判定を渡せる**：テストの成功・失敗を手がかりに、自分の変更を検証しながら進められる
- **AI が一度に考える範囲を限定できる**：小さな振る舞い単位で進めることで、複雑な要求を分けて扱える
- **テストが意図どおりに失敗することを確認できる**：実装前の Red を見ることで、テストが何を検出するか確かめられる
- **壊れたときに調べる範囲が狭い**：小さく変更して検証するため、まず直近の変更から原因を調べられる

合否判定が示すのは、テストに書いた期待を満たすかどうかです。期待値が仕様どおりかは、人間も確認します。

## AI 駆動開発で TDD を実践するメリット（2/2）

- **脱線しても戻る範囲が小さい**：サイクルごとにコミットしていれば、直前にテストが通っていた地点を見つけやすくなる
- **人間にとってレビューしやすい**：差分が小さなコミットに分かれ、確認する範囲と変更の目的を追いやすくなる
- **リファクタリングの安全網がある**：既存テストを実行することで、構造を整理した際の意図しない動作の変化を検出できる
- **コンテキストが切れても再開しやすい**：テストとコミット履歴から、実現済みの振る舞いや変更の経緯を確認できる

これらは、TDD に加えて、小さくコミットする運用を組み合わせたときのメリットです。
未完了のテストリストも残すと、次に何をするかを引き継ぎやすくなります。

## TDD で生成されやすくなるコードの特性

- **テストしやすい構造**：外部依存を分離するなど、振る舞いを個別に確認できる構造を考えるきっかけになる
- **小さく明確な責務**：小さな振る舞いを積み重ね、リファクタリングで重複や役割を見直せる
- **テストとして残る仕様**：入力と期待結果が、具体的で実行可能な例として残る
- **変更を検証できる仕組み**：既存テストで、意図しない振る舞いの変化を検出できる

TDD を使えば、自動的に責務が分かれたり、外部依存が分離されたりするわけではありません。
テストを書きやすいかを考え、構造を見直すことが、こうした特性につながります。

## なぜ保守しやすくなるのか

| コードの特性      | 保守するときのメリット     |
| ----------- | --------------- |
| テストしやすい構造   | 修正箇所を個別に検証できる   |
| 責務が小さく明確    | 変更の影響範囲を把握しやすい  |
| 仕様がテストとして残る | 既存の振る舞いを理解しやすい  |
| 回帰テストがある    | 変更による不具合を検出しやすい |

結果として、「安心して変更できるコード」に近づきます。
ただし、テストが成功しても、仕様をすべて満たしたと証明できるわけではありません。

送料計算で1,000円と3,000円しかテストしていなければ、`>= 3000` を `== 3000` に変えても両方成功します。
3,001円のケースを加えると、その違いを検出できます。
何をテストするかの判断も、保守性を支える大切な要素です。

## 注意：AI が TDD を実践したか確認しよう

AI が指示どおりに TDD を実践する保証はありません。
コードに加え、実行ログやコミット履歴を確認しましょう。

- テストを先に書いているか
- 意図した理由で Red になっているか
- Green で既存テストも成功しているか
- 必要に応じて Refactoring を検討し、変更後も成功を確認しているか
- 小さな単位でコミットしているか

コミット履歴だけでは、テストを書いた順序や Red を確認した事実までは分かりません。
実行したコマンド・テスト件数・失敗数を含むログと合わせて確認してください。
テスト0件での成功や、実行せずに「通るはず」と説明している場合も見逃さないようにします。

テストの期待値を実装に合わせて変えていないか、今回の仕様にない機能を追加していないかも、差分から確認します。
実行できない場合は、その旨を報告してもらいましょう。

## まとめ

AI に TDD を実践させることで、次の効果を期待できます。

- 小さな単位で実装・検証できる
- テストによって振る舞いを明文化できる
- 変更しやすい構造を作りやすくなる
- テストとコミット履歴が保守を助ける

「何を作るか」だけでなく、「どう作るか」も AI に指示しましょう。
そして、実行結果を確認するところまでを習慣にしてください。
まずは、小さな機能を依頼するときに、このおまじないを追加するところから始めてみましょう。

> t_wada の TDD に則り、
> Red → Green → Refactoring のサイクルを短く回し、
> コミットしていってください。

## 参考資料

- [テスト駆動開発（Kent Beck 著、和田卓人 訳）](https://www.amazon.co.jp/dp/4274217884)
- [Kent Beck「テスト駆動開発の定義」の翻訳と解説](https://t-wada.hatenablog.jp/entry/canon-tdd-by-kent-beck)

## 付録：送料計算で TDD を試す

ここからは、手元で AI と送料計算を作る演習です。
本編の流れを観察できるよう、段階ごとに AI を止めます。人間は結果と差分を確認してコミットします。
これは学習用の役割分担です。各段階での停止や、人間によるコミットまでを TDD の定義に含めるわけではありません。

### 対象者と事前準備

Java のクラス・メソッド・条件分岐と、JUnit の `@Test`・`assertEquals` を読める方が対象です。
JUnit が初めてなら、先に [テスト入門の「Util のテスト」](/Practical-Introduction-to-Spring-Boot/SpringBootテスト入門/テスト入門.md#util-のテスト普通の-java-のテスト) に取り組んでください。

次を用意します。

- JDK 21 と Maven 3.9 系
- ファイルの編集とテスト実行ができる AI コーディング支援ツール（エージェント型 CLI やエディター統合型など）
- Git と、変更内容を確認できるエディター

この演習は普通の Java クラスで進めます。Spring の起動、Web API、DB は使いません。
既存アプリとは別の空のディレクトリを作り、次の `pom.xml` を保存してください。

```xml title="pom.xml"
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>dev.mikoto2000</groupId>
  <artifactId>shipping-tdd</artifactId>
  <version>1.0-SNAPSHOT</version>
  <properties>
    <maven.compiler.release>21</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>6.0.3</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.14.1</version>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>3.5.4</version>
      </plugin>
    </plugins>
  </build>
</project>
```

JUnit の依存関係と Maven での実行設定は [JUnit 6.0.3 の公式ガイド](https://docs.junit.org/6.0.3/running-tests/build-support.html) を参照できます。
この章では Maven を直接使います。以降のコマンドは、この演習の `pom.xml` があるディレクトリで実行してください。

```bash
java -version
mvn -version
git init
```

Java が 21 以上、Maven が 3.9 系であることを確認します。
`.gitignore` に `target/` を記載し、`pom.xml` と一緒に最初のコミットを作ります。

```bash
git add pom.xml .gitignore
git commit -m "Set up shipping TDD exercise"
```

Git の名前とメールアドレスが未設定の場合は、自分の設定を済ませてからコミットしてください。

### 1. まずは、おまじないを唱えてみる

AI に、次のプロンプトを渡します。

```text
商品合計金額から送料を計算する機能を Java で作ってください。
送料は通常500円、商品合計が3,000円以上なら無料です。
商品合計は0以上の整数とし、負数や通貨換算は今回の対象外です。

t_wada の TDD に則り、Red → Green → Refactoring のサイクルを短く回してください。
コミットは私が行うので、AI はファイルの変更とテスト実行までを担当してください。

まず期待する動作をテストリストにしてください。
今回は学習のため、最初のテストを追加して実行したところで止まり、
結果を報告してください。実装はその結果を確認してから進めます。
```

AI が一度に完成させてしまわないよう、学習中は段階ごとに止めます。
次の手順から、手元の変更とテスト結果を確認しながら先へ進めてください。
付録のコードは各段階の確認用です。先に完成版をまとめて貼り付けず、一段階ずつ試しましょう。
この演習では、あなたが仕様と差分・実行結果を確認し、次へ進む指示とコミットを担当します。
AI にはテストと実装の編集・実行を頼み、確認の区切りごとに止まってもらいます。

| 手順  | あなたが行うこと                                | AI に頼むこと                    |
| --- | --------------------------------------- | --------------------------- |
| 1   | プロンプトを渡し、テストリストを確認する                    | テストリストの作成、最初のテストの追加・実行      |
| 2   | コンパイルエラーと期待値の不一致を区別し、成功後に差分を確認してコミットする  | 骨組みの作成・実行、確認後の Green の実装・実行 |
| 3   | 新しいテストの失敗を確認し、実装を指示する。成功後に差分を確認してコミットする | テストの追加・実行、確認後の実装変更・実行       |
| 4   | ケースを1つずつ選び、結果と差分を確認してコミットする             | 各テストの追加・実行、条件式を一時変更する確認演習   |
| 5   | 動作と差分を確認してコミットする                        | リファクタリングと変更前後のテスト実行         |
| 6〜7 | AI への指示とプロンプトを自分の言葉で書く                  | 作業の依頼は不要                    |

#### 期待する動作をリストにする

最初のテストリストは、たとえば次のようになります。

- [ ] 商品合計が1,000円なら送料は500円
- [ ] 商品合計が3,000円なら送料は0円
- [ ] 商品合計が2,999円なら送料は500円
- [ ] 商品合計が3,001円なら送料は0円
- [ ] 商品合計が0円なら送料は500円

リストは、これから確かめたいことのメモです。すべてのテストコードを先に書く必要はありません。
この演習では、0円でも通常送料を適用します。送料無料の条件を満たさないためです。
実務なら、注文できる最低金額なども関係者に確認してから仕様を決めます。

### 2. 最初の一周：送料500円を実現する

#### Red：期待する動作を1つのテストにする

手順1で AI が追加した最初のテストを開き、次の例と照合してください。
この演習では「商品合計が1,000円なら送料は500円」から進めます。AI が別のケースを選んだ場合は、このケースに変更して再実行するよう頼みます。
ファイルの配置と package 宣言も確認します。同じファイルを作り直す必要はありません。

```java title="src/test/java/dev/mikoto2000/tdd/ShippingFeeCalculatorTest.java"
package dev.mikoto2000.tdd;

import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.api.Test;

class ShippingFeeCalculatorTest {
  @Test
  void 商品合計が1000円なら送料は500円() {
    ShippingFeeCalculator calculator = new ShippingFeeCalculator();

    assertEquals(500, calculator.calculate(1000));
  }
}
```

AI が実行したコマンドと結果を確認します。この演習で使うコマンドは次のとおりです。
`-DfailIfNoTests=true` は、テストが1件も見つからない場合にビルドを失敗させる指定です。
テストの配置などを誤り、0件のまま成功したと受け取ることを防ぎます。

```bash
mvn -DfailIfNoTests=true test
```

まだ対象のクラスがないので、コンパイルエラーになります。
これは必要なクラスがないことを示しています。期待値と実際の計算結果を比べる段階には、まだ到達していません。
AI に次の骨組みを作って同じコマンドを実行し、結果を報告して止まるよう頼みます。

```java title="src/main/java/dev/mikoto2000/tdd/ShippingFeeCalculator.java"
package dev.mikoto2000.tdd;

public class ShippingFeeCalculator {
  public int calculate(int subtotal) {
    return 0;
  }
}
```

今度はテストが実行され、期待値500に対して実際の値が0なので失敗します。
出力にテスト1件、失敗1件が含まれることを確認してください。以下は確認すべき箇所の例で、実行ログの全文ではありません。

```text
expected: <500> but was: <0>
Tests run: 1, Failures: 1, Errors: 0, Skipped: 0
```

**テストを書いたことと、そのテストが問題を検出すると確かめたことは別です。**
依存関係の取得失敗や構文エラーなら、環境やコードを直してから期待値の不一致を確認します。

AI には、次のように続けて指示できます。

```text
テストが期待値500、実際の値0で失敗していることを確認しました。
このテストを通すために必要な実装を行い、テストを再実行してください。
まだ送料無料の条件は実装しないでください。
```

#### Green：今のテストを通す

AI が変更した `calculate` の本体を確認します。この段階の実装例は次のとおりです。

```java title="ShippingFeeCalculator.java（Green のメソッド本体）"
public int calculate(int subtotal) {
  return 500;
}
```

AI の再実行結果を読み、1件が成功することを確認します。確認すべき出力の例は次のとおりです。

```text
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
```

`Tests run` が期待する件数であり、`Failures`・`Errors`・`Skipped` がすべて0であることを確認します。
引数を使っていないことに、違和感はあるでしょうか。
今のテストには十分ですが、送料計算全体の完成ではありません。次の振る舞いは次の一周で実現します。
固定値を返す実装は、歩幅を小さくするための選択です。TDD で毎回固定値から始める必要があるわけではありません。

#### Refactoring：見直し、必要なければ進む

テストが通った状態で、重複や読みにくさがないか見直します。
今回はまだ小さいので、そのまま進めます。毎回何かを変更する義務はありません。
テストリストの最初の項目を完了にし、差分を確認してコミットします。

```bash
git diff
git add src/main/java/dev/mikoto2000/tdd/ShippingFeeCalculator.java src/test/java/dev/mikoto2000/tdd/ShippingFeeCalculatorTest.java
git diff --cached
git commit -m "Return standard shipping fee for a 1000 yen subtotal"
```

ここまでが最初の一周です。以降も、テストが通った意味のある区切りで、対象のファイルを指定してコミットします。
コミットは変更を見返したり戻したりするための区切りとして使います。この演習では Green の状態を記録します。

### 3. 次の一周：送料無料の条件を追加する

次は「商品合計が3,000円なら送料は0円」を選びます。
AI には、次のテストを追加して失敗を確認するところまで頼みます。
追加先は既存の `ShippingFeeCalculatorTest` クラスの中です。AI の変更を次の例と照合してください。

```java title="ShippingFeeCalculatorTest.java に追加（3000円）"
@Test
void 商品合計が3000円なら送料は0円() {
  ShippingFeeCalculator calculator = new ShippingFeeCalculator();

  assertEquals(0, calculator.calculate(3000));
}
```

AI に同じ Maven コマンドを実行してもらいます。今の実装は常に500を返すので、テスト2件のうち新しい1件が失敗します。
期待値0、実際の値500であることを確認したら、AI に実装の変更と再実行を頼みます。実装例は次のとおりです。

```java title="ShippingFeeCalculator.java（送料無料の条件を追加）"
public int calculate(int subtotal) {
  if (subtotal >= 3000) {
    return 0;
  }
  return 500;
}
```

テストを実行し、2件とも成功することを確認します。
追加したテストだけでなく、最初のテストも通すことが大切です。新しい変更によって、すでに実現した動作が壊れていないか確かめます。
見直しを行い、テストリストの項目を完了にしてからコミットしてください。

#### 「短く回す」とは何か

今回は、期待を1つ追加し、そのために変更し、結果を確認しました。
変更が小さいと、失敗したときに調べる範囲も小さくなります。人間が AI の変更を確認する負担も抑えやすくなります。
「短い」は、秒数や行数を厳密に決めることではありません。一度に扱う振る舞いを絞ることから始めましょう。

### 4. 境界を確かめる：緑になってから考えること

ここで、次の問いを考えてから AI と作業しましょう。

> `subtotal >= 3000` を `subtotal == 3000` に変えると、今の2件のテスト結果はどうなるでしょうか。

今ある入力は1,000円と3,000円だけです。どちらの条件式でも、この2件は成功します。
すべて緑でも、テストでまだ区別できない間違いがあります。

テストリストから、2,999円、3,001円、0円のケースを1つずつ選び、AI にテストの追加と実行を頼みます。
追加先は、既存の `ShippingFeeCalculatorTest` クラスの中です。各追加後に結果を確認してから次へ進んでください。

まず2,999円のケースを追加します。`Tests run: 3` となり、全3件が成功することを確認します。

```java title="ShippingFeeCalculatorTest.java に追加（2999円）"
@Test
void 商品合計が2999円なら送料は500円() {
  ShippingFeeCalculator calculator = new ShippingFeeCalculator();

  assertEquals(500, calculator.calculate(2999));
}
```

次に3,001円のケースを追加します。`Tests run: 4` となり、全4件が成功することを確認します。

```java title="ShippingFeeCalculatorTest.java に追加（3001円）"
@Test
void 商品合計が3001円なら送料は0円() {
  ShippingFeeCalculator calculator = new ShippingFeeCalculator();

  assertEquals(0, calculator.calculate(3001));
}
```

最後に0円のケースを追加します。`Tests run: 5` となり、全5件が成功することを確認します。

```java title="ShippingFeeCalculatorTest.java に追加（0円）"
@Test
void 商品合計が0円なら送料は500円() {
  ShippingFeeCalculator calculator = new ShippingFeeCalculator();

  assertEquals(500, calculator.calculate(0));
}
```

`>=` で実装していれば、追加したテストは最初から通ります。
既存の動作を確かめるテストの追加なので、失敗させるために実装を変更する必要はありません。

確認の演習として、AI に一時的に `>=` を `==` に変えて実行し、結果を報告して止まるよう頼みます。
3,001円のテストが失敗するはずです。確認できたら必ず `>=` に戻して再実行するよう頼み、全5件が通ることを確認します。
テストリストを更新し、正しい実装と追加したテストをコミットしてください。

**Green は、書いたテストの範囲で期待を満たした状態です。**
仕様を十分に確かめているかは、人間も考える必要があります。

#### 5件そろったテストの確認

ここまでのテストクラス全体を再掲します。5ケースがそろい、すべて成功することを確認してください。
メソッドを並べる順序は問いません。

```java title="ShippingFeeCalculatorTest.java（5件そろった状態）"
package dev.mikoto2000.tdd;

import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.api.Test;

class ShippingFeeCalculatorTest {
  @Test
  void 商品合計が1000円なら送料は500円() {
    ShippingFeeCalculator calculator = new ShippingFeeCalculator();

    assertEquals(500, calculator.calculate(1000));
  }

  @Test
  void 商品合計が3000円なら送料は0円() {
    ShippingFeeCalculator calculator = new ShippingFeeCalculator();

    assertEquals(0, calculator.calculate(3000));
  }

  @Test
  void 商品合計が2999円なら送料は500円() {
    ShippingFeeCalculator calculator = new ShippingFeeCalculator();

    assertEquals(500, calculator.calculate(2999));
  }

  @Test
  void 商品合計が3001円なら送料は0円() {
    ShippingFeeCalculator calculator = new ShippingFeeCalculator();

    assertEquals(0, calculator.calculate(3001));
  }

  @Test
  void 商品合計が0円なら送料は500円() {
    ShippingFeeCalculator calculator = new ShippingFeeCalculator();

    assertEquals(500, calculator.calculate(0));
  }
}
```

### 5. Refactoring：動作を守りながら読みやすくする

テストが5件通ったところで、AI に次のように頼みます。

```text
送料計算の動作を変えずに、500と3000が何を表すか名前で分かるようにしてください。
変更前後にテストを実行してください。
今回の仕様にない機能の追加やクラスの分割は不要です。
```

変更後のクラス全体は、次のようになります。

```java title="ShippingFeeCalculator.java（リファクタリング後）"
package dev.mikoto2000.tdd;

public class ShippingFeeCalculator {
  private static final int STANDARD_SHIPPING_FEE = 500;
  private static final int FREE_SHIPPING_THRESHOLD = 3000;

  public int calculate(int subtotal) {
    if (subtotal >= FREE_SHIPPING_THRESHOLD) {
      return 0;
    }
    return STANDARD_SHIPPING_FEE;
  }
}
```

AI が元の `src/main/java/dev/mikoto2000/tdd/ShippingFeeCalculator.java` を変更したことを確認します。
新しいファイルを追加する操作ではありません。
変更前後のテスト実行結果を読み、全5件が成功することを確認します。
テストの期待値は変えません。500や3,000という具体的な仕様を確認するためです。

| 変更       | この演習での例                 |
| -------- | ----------------------- |
| 機能追加     | 3,000円以上なら送料を0円にする      |
| リファクタリング | 計算結果を保ち、送料や境界値を定数の名前で表す |

リファクタリングは、外から見た動作を保ちながら内部の構造を改善することです。
テストがすべての動作を証明するわけではないので、差分も読み、条件式や返す値が変わっていないか確認します。
この規模では、送料の戦略クラスや設定用の仕組みまで作る必要はありません。
整理する価値があるかを判断することも、この段階の仕事です。確認後、変更をコミットします。

### 6. AI に任せるとき、人間が確認すること

AI に TDD と指示しても、常に期待どおりの手順になるとは限りません。
コードと合わせて、変更の順序や実行結果を確認します。

| AI の進め方             | 確認・指示すること                          |
| ------------------- | ---------------------------------- |
| テストと完成した実装をまとめて出す   | まずテストを追加し、実装を変える前の失敗を確認してもらう       |
| 「テストは通るはず」と説明する     | 実行コマンド・件数・結果を確認する。実行できない場合は明示してもらう |
| テストが失敗したので期待値を書き換える | 仕様に照らして、テストと実装のどちらに誤りがあるか判断する      |
| 将来に備えた機能を追加する       | 今回選んだ振る舞いに変更を絞ってもらう                |
| テスト0件でビルドに成功する      | テストが検出されているか確認する。成功表示だけで判断しない      |

#### ミニ演習：次の指示を考える

AI から、次の報告がありました。

> 送料無料のテストは失敗しました。実装に合わせて期待値を500に直したので、すべてのテストが通りました。

そのまま次へ進めてよいでしょうか。送料の仕様に戻り、AI への指示を書いてみてください。

指示の一例です。

```text
商品合計が3,000円以上なら送料は0円、という仕様を確認してください。
期待値を500にした変更を元に戻し、期待値0でテストが失敗することを確認してください。
その後、実装を修正して、既存のテストも含めて実行してください。
```

テスト側が間違っている場合もあるため、期待値を一切変えてはいけないわけではありません。
何を正しいとするかを、実装の都合だけで決めないことが大切です。

### 7. おまじないを自分の言葉にする

最後に、冒頭のプロンプトを書き直してみます。コミットは引き続きあなたが担当します。

```text
送料計算機能を Java で実装してください。
送料は通常500円、商品合計が3,000円以上なら無料です。
商品合計は0以上の整数とし、負数や通貨換算は今回の対象外です。

次の進め方で作業してください。
1. 期待する動作をテストリストにまとめる。
2. リストから次に実現する振る舞いを1つ選び、テストを追加する。
3. 実装を変更する前に実行し、意図した理由で失敗することを確認する。
4. そのテストを通すために必要な実装を行う。
5. それまでに書いたテストも含めて、すべて通ることを確認する。
6. 動作を保ったまま改善できる点を検討し、必要ならリファクタリングする。
7. 変更後もテストを実行し、差分を確認する。
8. テストリストを更新し、結果を報告して止まる。コミットは私が行う。
9. 私の指示を受けて、リストに残る次の振る舞いへ進む。

既存の実装がすでに満たすケースは、確認用のテストとして追加し、結果を報告してください。
各サイクルで、選んだ振る舞いとテストの実行コマンド・件数・結果を簡潔に報告してください。
テストを実行できない場合は、その旨を明示してください。
```

冒頭の指示を、各段階で確認できる手順に書き直しました。

| 冒頭の指示                       | 書き直して明示したこと                            |
| --------------------------- | -------------------------------------- |
| 「TDD に則り、短く回す」              | 振る舞いを1つ選び、意図した失敗と既存テストの成功を確認する         |
| 「Red → Green → Refactoring」 | 動作を保つ改善を検討し、変更後もテストと差分を確認する            |
| 最初のテスト実行後に止まる               | 各サイクルで止まり、人間がコミットして次の指示を出す             |
| 結果を報告する                     | 選んだ振る舞い・実行コマンド・件数・結果を報告し、実行できない場合も明示する |
| 既存実装が満たすケースの扱いは未指定          | 確認用のテストとして追加し、結果を報告する                  |

#### 振り返り

次の問いを、自分の言葉で説明してみましょう。

- 最初のテストが失敗するところを確認する理由
- `return 500` から始めたことで、一度に考える範囲がどう変わったか
- 追加したテストと既存のテストを一緒に実行する理由
- リファクタリングで変えるものと保つもの
- AI が「テストは通りました」と言ったときに確認すること

最初は、おまじないとして渡した一文でした。
今なら、その指示で AI に何をしてほしいのか、実際にできているかを、自分の言葉で確かめられます。
