メインコンテンツへスキップ
見出し画像

Claude Codeで作ってCodex CLIでレビューする、AI駆動開発の全自動化をSkillで試した話

    もともと今回やりたかったのは、Claude Code の skill をちゃんと育てる実験でした。毎回同じような指示をコピペして、仕様書を見せて、設計書を書かせて、レビューさせて……という流れを、もう少し賢く回せないかと思ったからです。ところが実際に試してみると、これは単なる skill 実験ではなく、AI駆動開発そのものの自動化にかなり近い話になってきました。Claude Code で作り、Codex CLI でレビューする流れを組むことで、前回説明した開発フローが、少しずつ“回る形”になってきたのです。

    前回の記事では、`SPEC.md` を起点にして、要件の確認、不明点の洗い出し、設計書の作成、さらにテストケースまでを順番に作る流れを整理しました。頭では分かっていても、実際にこれを毎回きちんと回すのは意外と面倒です。AI は賢いようでいて、放っておくと「それっぽく作って終わり」になりがちですし、人間の側も途中で「まあこのくらいでいいか」と雑になりやすい。ここに skill を入れる意味がありました。

    今回やったのは、Claude Code に「次に何をするべきか」を判断させる親 skill を作り、その下で設計ドキュメント作成の流れを段階的に進めるようにしたことです。ただ設計書をまとめて作らせるのではなく、`SPEC.md` を確認し、設計書を1つ作り、その場でレビューし、不明点を `QandA.md` に残し、必要なら修正してから次へ進む。さらに、レビュー役として Codex CLI を差し込むことで、Claude Code が作ったものを別の視点で見直す形にしました。


    画像

    この構成にした理由は単純で、Claude Code だけに全部やらせると、どうしても「自分で作ったものを自分で軽く確認して終わる」流れになりやすかったからです。もちろんそれでも十分便利なのですが、AI駆動開発として考えると少し物足りません。設計や仕様の曖昧さは、作った本人より、少し外側から見たほうが見つかることが多い。そこで、作る側を Claude Code、レビュー側を Codex CLI に分けることで、無理やりでもチェックの層を増やしてみたわけです。

    なぜ skill を作ろうと思ったのか

    一番の理由は、毎回同じ説明を繰り返すのがしんどかったからです。

    私は前回の記事で、AI駆動開発の流れとして、まず `SPEC.md` を作り、AI に仕様をレビューさせ、不明点を `QandA.md` に落とし、そのあと `USECASE.md`、`SEQUENCE.md`、`CLASS.md`、`TESTCASE.md` と段階的に進めていくやり方を書きました。この流れ自体はかなり納得感がありましたし、実際にやってみても悪くありませんでした。

    ただ、問題はここからです。

    毎回これをやろうとすると、

    • まず仕様書を読ませる

    • 仕様書の曖昧点を洗い出させる

    • QandA を作らせる

    • 設計書を1つずつ作らせる

    • 作ったものをレビューさせる

    • 必要なら修正させる

    という指示を、その都度かなり丁寧に書かないと、こちらの思った通りには動かないことが多かったのです。

    AI は確かに便利です。ですが、便利だからこそ油断すると、こちらが期待している「段取り」までは守ってくれません。特に Claude Code のように、ある程度自律的に動けるものは、うまく使えば非常に強い反面、少し指示が曖昧だと、こちらが望んだ工程を飛ばしてショートカットしがちです。

    画像

    たとえば、

    「設計書を作って」

    とだけ言うと、必要な設計書を一気に作ってくれることはあります。でも、そのあとにこちらが本当に欲しいのは、「作ったので終わり」ではなく、

    • その設計書は仕様に合っているか

    • 曖昧な点はどこか

    • 他の設計書と矛盾していないか

    • 実装に進めるだけの具体性があるか

    まで確認した状態です。

    ここを毎回人間が口頭で補っていると、結局「便利なはずなのに、毎回似たようなことを説明しているな」という気分になってきます。そこで思ったのが、だったらこの流れ自体を skill にしてしまえばいい、ということでした。


    画像

    最初に作った構成

    最初はかなり素朴でした。

    まず、全体を見て次に何をするか判断する親役として `start-skill` を置き、その下に

    • `spec-to-design`

    • `review-to-qa`

    • `ops-daily-triage`

    • `draft-to-note`

    のような専門 skill を置く構成にしました。

    考え方としては単純で、親 skill が

    • 今は仕様レビューが必要なのか

    • 設計書を作る段階なのか

    • レビュー結果を整理する段階なのか

    • 記事化する段階なのか

    を判断して、必要な skill を選んで進める、という形です。

    この時点ではかなり期待していました。
    「進めて」とか「レビューして」と言えば、あとはワークスペースの状態を見ていい感じに流してくれるのではないか、と。

    実際、ここまではそれなりにうまくいきました。
    `SPEC.md` があれば `spec-to-design` に進む、設計書がなければ作る、差分が大きければレビューを考える、といった大きな流れは、かなりそれっぽく動くようになりました。

    ただ、ここで次の問題が出てきました。

    画像

    うまくいかなかった点

    最初にぶつかったのは、AI がこちらの思っているよりずっと「近道」が好きだということです。

    こちらとしては、

    1. 仕様書を読む

    2. 曖昧点を洗い出す

    3. QandA に落とす

    4. 設計書を1つ作る

    5. その設計書をレビューする

    6. 必要なら修正する

    7. 次の設計書へ進む

    という段階的な流れを期待していました。

    でも実際には、

    1. 設計書を全部作る

    2. 最後にまとめてレビューする

    3. 軽微な修正をする

    4. では次へ進みましょう

    のように動いてしまうことが多かったのです。

    ぱっと見ると、これは一応それなりに正しい動きです。
    でも、こちらの欲しいものとは少し違います。

    なぜなら、全部作ってから最後にまとめてレビューするやり方だと、途中の曖昧さが後ろまで持ち越されるからです。たとえば `USECASE.md` の時点でふわっとした解釈をしてしまうと、その解釈を前提に `SEQUENCE.md` や `CLASS.md` が作られてしまう。すると最後にレビューしても、直す範囲が広がってしまいます。

    つまり、私が欲しかったのは「最後に採点するAI」ではなく、「各段階でちょっと口うるさく止めてくれるAI」だったわけです。

    ここで、skill の書き方そのものを見直す必要が出てきました。

    Claude Code と Codex CLI を分けた理由

    画像

    もう一つ大きかったのは、Claude Code だけに全部やらせると、どうしても「自分で作って自分で軽く確認して終わる」流れになりやすいことでした。

    もちろん、それでも十分便利です。
    むしろ普通に使うだけなら、かなり優秀です。

    でも、今回やりたかったのは AI駆動開発の流れを少し厳密にすることでした。設計書を作るだけなら1人でもできるけれど、そこに別の視点からのレビューを挟んだほうが、開発の質は安定しやすい。人間同士でもそうですが、作る人と見る人が同じだと、どうしても見落としが出やすくなります。

    そこで、作る側を Claude Code に、レビュー側を Codex CLI に分けることにしました。

    つまり、

    • Claude Code は流れを進める親役

    • Codex CLI はレビュー役

    という二層構成にしたわけです。

    この構成にすると、少なくとも「自分が書いたものを自分で何となく OK にする」感じはかなり減ります。レビューを別の AI に投げるだけでも、曖昧点や不足の指摘のされ方が変わりますし、何より flow の中に「一度立ち止まる工程」が入るのが大きいです。

    実際、この構成にしてからは、設計書を作ったあとにそのまま次へ行くのではなく、「ここは本当に大丈夫か」をもう一度別視点で見させる流れが組みやすくなりました。

    skill を育てるとはどういうことか

    画像

    今回やっていて面白かったのは、skill を作ること自体が、ちょっとした開発作業だったことです。

    最初は「SKILL.md を書けばいいのかな」くらいの気持ちだったのですが、実際にはそんなに単純ではありませんでした。

    たとえば「レビューする」と書いても、AI はそれを

    • その場で細かくレビューする

    • 最後にまとめてざっと見る

    • 軽く確認して通す

    のどれとして解釈してもおかしくありません。

    つまり、skill の中でやりたいことを自然言語で書くだけでは足りず、

    • どの段階で止まるのか

    • 次に進んでよい条件は何か

    • 不明点をどこへ出すのか

    • 修正はどの時点で行うのか

    • レビューは内部確認ではなく外部レビューであること

    • Codex CLI をどの場面で呼ぶのか

    といったことを、かなり細かく決める必要がありました。

    言い換えると、skill を育てるというのは「賢い AI にふわっとお願いすること」ではなく、「作業フローを段階ごとに設計し、抜け道を減らしていくこと」に近かったです。

    この感覚は、少し昔のマクロ作りや自動機械の段取り作りにも似ています。AI だから何となく全部うまくやってくれそうに見えますが、実際には「何をどの順番で、どこまで終わらせたら次へ進むか」をちゃんと決めてやらないと、すぐに近道をしてしまいます。便利だけれど、油断するとかなり自由奔放です。賢い後輩というより、発想力のある近道好きの同僚と仕事している感じかもしれません。

    最終的にどういう流れになったか

    試行錯誤の末、かなりしっくりきたのは次の流れです。

    まず `start-skill` が全体の入口になります。ここでワークスペースを見て、

    • 仕様書レビューが必要か

    • 設計書作成に進むべきか

    • すでにレビュー結果があるか

    • どの段階が足りないか

    を判断します。

    `SPEC.md` しかない場合は、まず `SPEC.md` 自体をレビューして、重大な曖昧さがあれば `QandA.md` に整理します。その後、`spec-to-design` が動きます。

    ここで大事なのは、`spec-to-design` がもう単なる「設計書を全部作る skill」ではなくなったことです。設計書を1つ作るたびに、その場で Codex CLI にレビューさせ、不明点を `QandA.md` に追記し、軽微な問題は修正してから次へ進む。つまり、

    • 作成

    • レビュー

    • QandA

    • 修正

    を1ドキュメントごとに回すわけです。

    そして今回、個人的にいちばん大きかったのはここでした。
    もともとは、

    • Claude Code を開く

    • Codex CLI を別で立ち上げる

    • さらに ChatGPT も使う

    という感じで、複数のAIを行ったり来たりしながら作業していました。これが地味に面倒でしたし、流れが切れやすかったのです。AI駆動開発をやろうとしているのに、AIを使う人間のほうがタブやターミナルを右往左往しているのは、なかなかシュールです。

    でも、Claude Code から Codex CLI を呼び出せるようにしたことで、この流れがかなり変わりました。親役は Claude Code のまま、必要な場面で Codex CLI をレビュー役として呼び出せるようになったので、少なくとも自分が毎回手で切り替える必要はかなり減りました。つまり、ただ「AIを複数使っている」状態から、1つの流れの中でAI同士に役割を持たせて動かす状態に近づいたわけです。

    この差は想像以上に大きかったです。
    単に手間が減るだけではなく、作業の流れが切れにくくなりました。設計書を作ったら、そのままレビューへ進み、必要なら修正し、不明点は `QandA.md` に残し、次へ進む。人間が毎回「次は Codex で見て、その次は ChatGPT に相談して……」と交通整理しなくても、かなり一連の流れとして回るようになってきました。

    もちろん、完全に放置できるわけではありません。
    それでも、以前のように AI を3つ並べて、その間を人間がメッセンジャーみたいに走り回る状態に比べると、かなり“全自動化”に近づいた実感があります。今回いちばん大きかったのは、skill の精度が上がったこと以上に、Claude Code を中心にして、作成とレビューの流れを1本につなげられたことだったのかもしれません。

    画像

    やってみて感じたこと

    今回の実験でいちばん大きかったのは、「AI に仕事をさせる」のと「AI が仕事の流れを守る」のは別問題だと分かったことです。

    文章を書く、設計書を作る、レビューする。
    こういう個別作業だけを見ると、今の AI はかなり強いです。ですが、複数の作業を順番に並べて、途中で確認し、必要なら止まり、修正しながら前へ進める、というワークフローになると、一気に難しさが出てきます。

    だからこそ、skill が効くのだと思います。
    単に便利機能としてではなく、AI に「段取り」を覚えさせるための仕組みとして。

    そして今回は、もう一つ大きな意味がありました。
    Claude Code と Codex CLI を別々に使うのではなく、Claude Code から Codex CLI を呼び出せるようにしたことで、AI駆動開発の流れがかなり一本化されたことです。これは単なる操作の省力化ではなく、開発フローそのものを崩れにくくする効果がありました。AI を複数使うなら、人間が毎回切り替えるより、役割を決めて流れの中に組み込んだほうがずっと強い。今回それをかなり実感しました。

    今回の話は、Claude Code の skill 実験として始まりました。でも振り返ってみると、やっていたのは skill 作りそのものより、AI駆動開発をどうすれば崩れにくい流れとして自動化できるかの試行錯誤だったのだと思います。Claude Code で作って、Codex CLI でレビューする。この組み合わせは、少なくとも今の自分にとってはかなり手応えがありました。

    まとめ

    今回やっていたことを一言で言うと、Claude Code の skill 実験をしながら、AI駆動開発の流れを少しずつ自動化していた、ということになると思います。

    最初の目的は、毎回のコピペや段取り説明を減らすことでした。ですが、実際にやってみると、重要だったのは単なる省力化ではありませんでした。仕様書を確認し、設計書を作り、その場でレビューし、不明点を `QandA.md` に残し、必要なら修正する。そうした流れを、AI がある程度崩さずに回せるようにすることのほうが大きかったです。

    そして、そのためには Claude Code だけでも、Codex CLI だけでも足りませんでした。作る役とレビューする役を分け、それを人間が毎回手で切り替えるのではなく、Claude Code から Codex CLI を呼び出す形にしたことで、やっと開発フロー全体が少し一本につながった感覚がありました。

    まだ完全な自動化には遠いですし、skill の書き方ひとつで挙動も変わります。それでも、以前よりずっと丁寧に考えながら進むようになりましたし、何より「AI に仕事を頼む」から「AI に流れを守らせる」方向へ、一歩進めた実感があります。個人的には、この感覚がいちばん面白かったところです。

    今回作った skill の中身や、どこでうまくいかず、どこを直したら動きが変わったのかも、もう少し具体的に書いてみようと思います。
    作成したスキルは以下です。
    SPEC.mdを置いたフォルダでClaude Codeのチャットで「/start-slill」を呼び出して使います。

    C:\Users\[ユーザー名]\.claude\skills\start-skill\SKILL.md

    ---
    name: start-skill
    description: ユーザーが『進めて』『続けて』『次をやって』『レビューして』『コードレビューして』『仕様書をレビューして』『厳しめにレビューして』のように曖昧に依頼したときに使う。ワークスペース内の SPEC.md、QandA.md、日報、監視ログ、記事下書き、コード差分を見て、次に行うべき作業を判断しそのまま実行する。成果物を生成した後はレビューを行い、問題があれば修正して次工程へ進む。レビュー依頼や大きなコード差分がある場合は Codex CLI を直接実行する。必要に応じて設計整理、運用日報整理、記事整形も行う。
    ---
    
    # start-skill
    
    ## 役割
    現在のワークスペースの状態を見て、次に行うべき作業を判断し、そのまま実行する親スキル。  
    「次に使うべき skill を選ぶだけ」で終わらせず、レビュー案件ではその場で Codex CLI を実行する。  
    成果物を生成した後はレビューを行い、問題があれば修正してから次工程へ進む。
    
    ## 判定ルール
    1. ユーザーが「レビューして」「コードレビューして」「仕様書をレビューして」「厳しめにレビューして」と依頼した場合、または大きなコード差分がある場合  
       → Codex CLI を直接実行する
    
    2. `SPEC.md` があり、設計書群が不足している  
       → まず `SPEC.md` 自体をレビューして不足・曖昧点を洗い出す。  
          判断が必要な点は `QandA.md` に整理する。  
          その後に、各ドキュメントを「作成 → Codexレビュー → QandA追記 → 修正」の順で進める `spec-to-design` を実行する
    
    3. `QandA.md` やレビュー結果があり、修正計画が未整理  
       → `review-to-qa`
    
    4. 日報や監視ログに異常があり、対応方針が未作成  
       → `ops-daily-triage`
    
    5. 技術メモや記事下書きがあり、公開向け整形が必要  
       → `draft-to-note`
    
    ## 実行手順
    
    ### レビュー以外の場合
    1. 主要ファイルと更新状況を確認する
    2. 上の判定ルールに沿って優先順位を付ける
    3. 今回使うべき skill を 1 つ選ぶ
    4. その理由を簡潔に示す
    5. 選んだ skill を実行して成果物を生成・更新する
    6. 生成・更新された成果物をレビューする
    7. 軽微な問題はその場で修正する
    8. 必要なら `QandA.md` に未確定事項を整理する
    9. 修正後の要点をまとめて、次工程を提案する
    
    ### SPEC.md から設計に進む場合
    1. `SPEC.md` を読み、要件・曖昧点・不足点をレビューする
    2. 重大な不足があれば `QandA.md` に整理する
    3. 実装可能な前提が揃っていれば `spec-to-design` を実行する
    4. `spec-to-design` が各成果物の「作成 → Codexレビュー → QandA追記 → 修正」を完了したことを確認する
    5. 最終要点をまとめて次工程を提案する
    
    ### レビュー時の実行手順
    1. レビュー対象を確認する  
       - コード差分または `SPEC.md` を確認する
    2. 現在のワーキングディレクトリ `.` を対象に Codex CLI を実行する
    3. ユーザーの依頼を短く要約してプロンプトに含める
    4. 結果を要約してユーザーに返す
    5. 必要なら `QandA.md` または `FIX_PLAN.md` を更新する
    
    ## レビュー時の実行コマンド
    
    ```bash
    codex exec --full-auto --sandbox read-only --cd . "<依頼内容> 確認や質問は不要です。具体的な提案・修正案・コード例まで自主的に出力してください。"
    ```
    
    ## 出力形式(レビュー以外)
    - 実行した skill 名
    - 選択理由
    - 使用した入力ファイル
    - 生成・更新したファイル
    - レビューで修正した点
    - `QandA.md` に切り出した未確定事項
    - 次工程の提案
    

    C:\Users\[ユーザー名]\.claude\skills\spec-to-design\SKILL.md

    ---
    name: spec-to-design
    description: SPEC.md が存在し、USECASE.md、SEQUENCE.md、CLASS.md、UI.md、TESTCASE.md が未作成または不足しているときに使う。ユーザーが『仕様から進めて』『設計書を起こして』『テストケースも作って』と依頼したとき、この skill を使って必要な md を生成する。各ドキュメントは作成後すぐに Codex CLI で個別レビューし、不明点は逐次 QandA.md に追記し、修正完了後に次のドキュメントへ進む。
    ---
    
    # spec-to-design
    
    ## 役割
    `SPEC.md` を起点にして、設計ドキュメント群を順番に生成する。  
    各ドキュメントは **作成 → Codex CLI で個別レビュー → QandA.md へ不明点追記 → 修正** の順で処理し、完了するまで次のドキュメントへ進まない。  
    最後に全体整合レビューを行う。
    
    ## 入力
    - `SPEC.md`
    - 既存の `USECASE.md`, `SEQUENCE.md`, `CLASS.md`, `UI.md`, `TESTCASE.md`
    - 関連コードや README(あれば)
    - 既存の `QandA.md`(あれば追記)
    
    ## 主な出力
    - `USECASE.md`
    - `SEQUENCE.md`
    - `CLASS.md`
    - `UI.md`
    - `TESTCASE.md`
    - `QandA.md`(不明点が出た時点で作成または追記)
    
    ## 実行原則
    - 各ドキュメントを全部まとめて作ってからレビューしない
    - 1つのドキュメントごとに完了させてから次へ進む
    - 各レビューは Codex CLI を使う
    - 内部レビューだけで済ませない
    - QandA.md は最後にまとめて作るのではなく、各レビュー時に逐次追記する
    - 軽微な問題はその場で修正する
    - 各フェーズはレビューと修正が終わるまで完了扱いにしない
    
    ## 実行手順
    
    ### フェーズ0: 仕様確認
    1. `SPEC.md` を読み、要件・非機能要求・制約・曖昧点を抽出する
    2. 実装不能な重大不足があれば `QandA.md` に整理する
    3. 実装可能なら次へ進む
    
    ### フェーズ1: USECASE.md
    1. `USECASE.md` を作成する
    2. 次のコマンドで Codex CLI に `USECASE.md` のレビューを依頼する
    
    ```bash
    codex exec --full-auto --sandbox read-only --cd . "今作成した USECASE.md を SPEC.md と照合してレビューしてください。確認や質問は不要です。曖昧点、不足、矛盾、改善案、必要な修正例まで自主的に出力してください。"
    ```
    
    3. レビュー結果を要約する
    4. 不明点があれば `QandA.md` に追記する
    5. 軽微な問題を修正する
    6. 修正後の `USECASE.md` を確定してから次へ進む
    
    ### フェーズ2: SEQUENCE.md
    1. `USECASE.md` と `SPEC.md` を元に `SEQUENCE.md` を作成する
    2. 次のコマンドで Codex CLI に `SEQUENCE.md` のレビューを依頼する
    
    ```bash
    codex exec --full-auto --sandbox read-only --cd . "今作成した SEQUENCE.md を SPEC.md と USECASE.md に照らしてレビューしてください。確認や質問は不要です。曖昧点、不足、矛盾、改善案、必要な修正例まで自主的に出力してください。"
    ```
    
    3. レビュー結果を要約する
    4. 不明点があれば `QandA.md` に追記する
    5. 軽微な問題を修正する
    6. 修正後の `SEQUENCE.md` を確定してから次へ進む
    
    ### フェーズ3: CLASS.md
    1. `SEQUENCE.md` と `SPEC.md` を元に `CLASS.md` を作成する
    2. 次のコマンドで Codex CLI に `CLASS.md` のレビューを依頼する
    
    ```bash
    codex exec --full-auto --sandbox read-only --cd . "今作成した CLASS.md を SPEC.md と SEQUENCE.md に照らしてレビューしてください。確認や質問は不要です。曖昧点、不足、矛盾、改善案、必要な修正例まで自主的に出力してください。"
    ```
    
    3. レビュー結果を要約する
    4. 不明点があれば `QandA.md` に追記する
    5. 軽微な問題を修正する
    6. 修正後の `CLASS.md` を確定してから次へ進む
    
    ### フェーズ4: UI.md
    1. `USECASE.md` と `SEQUENCE.md` を元に `UI.md` を作成する
    2. 次のコマンドで Codex CLI に `UI.md` のレビューを依頼する
    
    ```bash
    codex exec --full-auto --sandbox read-only --cd . "今作成した UI.md を SPEC.md と USECASE.md と SEQUENCE.md に照らしてレビューしてください。確認や質問は不要です。曖昧点、不足、矛盾、改善案、必要な修正例まで自主的に出力してください。"
    ```
    
    3. レビュー結果を要約する
    4. 不明点があれば `QandA.md` に追記する
    5. 軽微な問題を修正する
    6. 修正後の `UI.md` を確定してから次へ進む
    
    ### フェーズ5: TESTCASE.md
    1. ここまでの成果物を元に `TESTCASE.md` を作成する
    2. 次のコマンドで Codex CLI に `TESTCASE.md` のレビューを依頼する
    
    ```bash
    codex exec --full-auto --sandbox read-only --cd . "今作成した TESTCASE.md を SPEC.md、USECASE.md、SEQUENCE.md、CLASS.md、UI.md に照らしてレビューしてください。確認や質問は不要です。曖昧点、不足、矛盾、改善案、必要な修正例まで自主的に出力してください。"
    ```
    
    3. レビュー結果を要約する
    4. 不明点があれば `QandA.md` に追記する
    5. 軽微な問題を修正する
    6. 修正後の `TESTCASE.md` を確定する
    
    ### フェーズ6: 全体整合
    1. 全ドキュメントを横断して整合レビューする
    2. 必要なら次のコマンドで Codex CLI に全体整合レビューを依頼する
    
    ```bash
    codex exec --full-auto --sandbox read-only --cd . "USECASE.md、SEQUENCE.md、CLASS.md、UI.md、TESTCASE.md の整合性を横断レビューしてください。確認や質問は不要です。矛盾、不足、修正案を優先度順に自主的に出力してください。"
    ```
    
    3. ドキュメント間の矛盾を修正する
    4. 修正後の要点と未確定事項を要約して報告する
    
    ## 修正ルール
    - 表現揺れ、見出し不足、型ミス、軽微な抜けは即修正する
    - 設計判断が必要なものは `QandA.md` に切り出す
    - 未確定事項が残っていても、暫定方針を明記して次へ進んでよい
    - 暫定方針は `QandA.md` に必ず残す
    
    ## 出力形式
    - 各フェーズで生成・更新したファイル
    - 各フェーズでレビューして修正した点
    - `QandA.md` に追加した不明点
    - 全体整合レビューで直した点
    - 次工程へ進むための前提
    

    実際にこのスキルを動かすとどうなるか見てみましょう。
    まず「SPEC.md」には以下を使いました。凄く簡単な要求仕様です(何回も繰り返し動かしたので動作確認用に作りました)。

    Pythonでターミナル上で遊べる簡単なRPGを作ってください。
    対象は高校生です。
    主人公の名前を入力できるようにしてください。
    物語は短めで、3回以上の選択肢を入れてください。
    最後にエンディングが分岐するようにしてください。
    1ファイルで動くようにしてください。
    ファイル名は rpg.py にしてください。

    普段はこんなSPEC.mdになります。設計だけで数日かかります。


    これを元に出来たのが「ユースケース図(USECASE.md)」です。

    # USECASE.md
    
    ## 対象システム
    ターミナル上で動作する Python 製テキスト RPG(rpg.py)
    
    ## アクター
    - **プレイヤー**: ゲームを操作する高校生ユーザー
    
    ## 実装制約
    - 実装ファイルは `rpg.py` の1ファイルのみとする
    - ターミナル上の標準入力/標準出力だけで完結する
    - 外部ライブラリは使用しない(Python 標準ライブラリのみ)
    - 動作対象: Python 3.9 以上(`list[str]` 型注釈構文を使用するため)
    
    ## 高校生向けコンテンツ方針
    - 難しい語彙は避け、読み仮名不要な平易な文体とする
    - 暴力・グロテスクな表現は避ける
    - 1セッション全体を3シーン+エンディングで構成し、プレイ時間は5〜10分程度とする
    - 各選択肢の文言は1行以内で明確に意図が伝わるようにする
    
    ---
    
    ## ユースケース一覧
    
    ### UC-01: ゲーム起動
    - **概要**: rpg.py を実行してゲームを開始する
    - **事前条件**: Python 3.x がインストールされている
    - **基本フロー**:
      1. プレイヤーが `python rpg.py` を実行する
      2. タイトルとプロローグが表示される
    - **事後条件**: 主人公名入力画面へ遷移する
    
    ### UC-02: 主人公名の入力
    - **概要**: プレイヤーが主人公の名前を入力する
    - **事前条件**: ゲームが起動している
    - **基本フロー**:
      1. 「主人公の名前を入力してください:」が表示される
      2. プレイヤーが名前を入力して Enter を押す
      3. 入力された名前が以降の全シーンで使用される
    - **代替フロー**:
      - `name.strip() == ""` の場合(空文字・スペースのみ)、再入力を促す(ループ)
    - **正規化**: 保存値は `name.strip()` とし、前後空白を除去する
    - **事後条件**: 物語が始まる
    
    ### UC-03: 選択肢の選択(シーン1:入り口の選択)
    - **概要**: 古い洞窟の入り口で、進むか引き返すかを選ぶ(第1の分岐)
    - **事前条件**: プロローグシーンが終了している
    - **シナリオ**: 主人公は「魔王の洞窟」の入り口に立っている
    - **基本フロー**:
      1. シーンの状況説明が表示される
      2. 選択肢「1. 勇気を出して進む / 2. 一度引き返す」が表示される
      3. プレイヤーが番号を入力する
      4. 選択結果を内部スコアに反映して次のシーンへ遷移する
         - 「1. 進む」を選ぶと `brave_count += 1`
         - 「2. 引き返す」を選ぶと `escape_count += 1`
    - **代替フロー**:
      - 無効な入力の場合、再入力を促す
    - **事後条件**: シーン2へ進む
    
    ### UC-04: 選択肢の選択(シーン2:仲間の危機)
    - **概要**: 倒れている仲間に遭遇し、助けるか先に進むかを選ぶ(第2の分岐)
    - **シナリオ**: 洞窟内で同級生が罠にかかって動けなくなっている
    - **基本フロー**:
      1. シーンの状況説明が表示される
      2. 選択肢「1. 仲間を助ける / 2. 先を急ぐ」が表示される
      3. プレイヤーが番号を入力する
      4. 選択結果を内部スコアに反映して次のシーンへ遷移する
         - 「1. 助ける」を選ぶと `help_friend = True` および `brave_count += 1`
         - 「2. 先を急ぐ」を選ぶと `escape_count += 1`
    - **代替フロー**: UC-03 と同様
    - **事後条件**: シーン3へ進む
    
    ### UC-05: 選択肢の選択(シーン3:魔王との対決)
    - **概要**: 魔王との最終対決で、戦うか自己犠牲で封印するかを選ぶ(第3の分岐)
    - **シナリオ**: 魔王と対峙した主人公は二択を迫られる
    - **基本フロー**:
      1. シーンの状況説明が表示される
      2. 選択肢「1. 全力で戦う / 2. 自らを犠牲にして封印する」が表示される
      3. プレイヤーが番号を入力する
      4. 選択結果を内部スコアに反映してエンディング判定へ進む
         - 「1. 戦う」を選ぶと `brave_count += 1`
         - 「2. 自己犠牲」を選ぶと `sacrifice = True`
    - **代替フロー**: UC-03 と同様
    - **事後条件**: エンディング判定へ進む
    
    ### UC-06: エンディングの表示
    - **概要**: 過去の選択に応じたエンディングを表示する
    - **事前条件**: 第3回選択が完了している
    - **基本フロー**:
      1. 選択履歴を元にエンディング種別を判定する(下記判定ルール参照)
      2. 対応するエンディングテキストを表示する
      3. 「THE END」を表示してゲームを終了する
    - **エンディング判定ルール**(優先順位順):
      1. `sacrifice == True` → **エンディングC(自己犠牲の英雄)**: 自らを犠牲にして世界を救った
      2. `brave_count >= 2` → **エンディングA(勝利)**: 勇敢な戦士として魔王を倒した
      3. その他(A/C に該当しない場合)→ **エンディングB(消極的結末)**: 決断できずに魔王を止めきれなかった結末
    - **事後条件**: ゲームが終了する
    
    ---
    
    ## 補足
    - 選択肢は各シーンで2択とし、計3回の選択でエンディングが決まる
    - 各シーンは数段落以内の文章で構成する
    

    これを元にした「シーケンス図(SEQUENCE.md)」

    # SEQUENCE.md
    
    ## 概要
    `rpg.py` 実行時のメイン処理フローをシーケンス図(テキスト形式)で示す。
    
    ## 表示文ポリシー
    - 高校生向けに平易な文体を使う
    - 暴力・グロテスクな表現は避ける
    - 全体は 3 シーン + エンディングで 5〜10 分程度に収める
    - 各シーン説明・エンディング文には `hero_name` を差し込んで主人公感を出す
    
    ---
    
    ## シーケンス図
    
    ```
    プレイヤー          rpg.py(メイン処理)
       |                        |
       |--[python rpg.py 実行]->|
       |                        | タイトル・プロローグ表示
       |<---[タイトル表示]-------|
       |                        |
       |                        | === 主人公名入力ループ ===
       |<---[名前入力プロンプト]-|
       |--[名前入力]----------->|
       |                        | [name.strip() == ""] → 「1文字以上で入力してください」を表示して再ループ
       |                        | [有効名] hero_name = name.strip() で保存
       |<---[「{hero_name}の冒険が始まる!」表示]---|
       |                        |
       |                        | === シーン1: 入り口の選択 ===
       |<---[{hero_name}を主語にした場面説明]--------|
       |<---[選択肢表示]---------|  1.勇気を出して進む / 2.一度引き返す
       |--[番号入力]----------->|
       |                        | [無効入力] → 「1か2を入力してください」を表示して再ループ
       |                        | [1] brave_count += 1 → シーン2へ
       |                        | [2] escape_count += 1
       |                        |     「{hero_name}は一度村へ戻り、気持ちを整えて再び洞窟へ向かった」を表示
       |                        |     → シーン2へ(選択にかかわらずシーン2は同一)
       |                        |
       |                        | === シーン2: 仲間の危機 ===
       |<---[{hero_name}を主語にした場面説明]--------|
       |<---[選択肢表示]---------|  1.仲間を助ける / 2.先を急ぐ
       |--[番号入力]----------->|
       |                        | [無効入力] → 再ループ
       |                        | [1] brave_count += 1, help_friend = True
       |                        |     「{hero_name}は仲間を助け起こした。仲間は最後まで共に戦うと誓った」を表示
       |                        | [2] escape_count += 1
       |                        |     「{hero_name}は仲間を残して先へ進んだ」を表示
       |                        |
       |                        | === シーン3: 魔王との対決 ===
       |<---[{hero_name}を主語にした場面説明]--------|
       |                        | [help_friend==True]  「レオが駆けつけた!」を追加表示(ALLY_NAME 固定値)
       |                        | [help_friend==False] 主人公は一人で最終対決へ(追加表示なし)
       |<---[選択肢表示]---------|  1.全力で戦う / 2.自らを犠牲にして封印する
       |--[番号入力]----------->|
       |                        | [無効入力] → 再ループ
       |                        | [1] brave_count += 1
       |                        | [2] sacrifice = True
       |                        |
       |                        | === エンディング判定 ===
       |                        | [sacrifice == True]  → エンディングC
       |                        | [brave_count >= 2]   → エンディングA
       |                        | [else]               → エンディングB(A/C に該当しない場合)
       |<---[{hero_name}入りのエンディング文表示]----|
       |<---[THE END 表示]-------|
       |                        | プログラム終了
    ```
    
    ---
    
    ## 内部状態の変化
    
    初期値: `hero_name = ""`, `brave_count = 0`, `escape_count = 0`, `help_friend = False`, `sacrifice = False`
    
    | タイミング         | 変数               | 変化内容                                    |
    |--------------------|--------------------|---------------------------------------------|
    | 名前確定時         | `hero_name`        | `name.strip()` の値を保存                   |
    | シーン1 選択1      | `brave_count`      | +1                                          |
    | シーン1 選択2      | `escape_count`     | +1                                          |
    | シーン2 選択1      | `brave_count`      | +1、`help_friend = True`                    |
    | シーン2 選択2      | `escape_count`     | +1                                          |
    | シーン3 選択1      | `brave_count`      | +1                                          |
    | シーン3 選択2      | `sacrifice`        | `True`                                      |
    
    ---
    
    ## エンディング判定フロー
    
    ```
    if sacrifice == True:
        → エンディングC(自己犠牲の英雄)
    elif brave_count >= 2:
        → エンディングA(勝利)
    else:
        → エンディングB(消極的結末)
    ```
    
    エンディングBは「上記A/C に該当しない場合の消極的結末」であり、`escape_count` による判定は行わない。
    
    ---
    
    ## 入力バリデーション共通処理
    
    各選択肢入力箇所で共通の再入力ループを使用する:
    
    ```
    loop:
        入力値を受け取る
        if 入力値 in 有効選択肢:
            break
        else:
            「1か2を入力してください。」を表示
    ```
    
    名前入力の場合:
    ```
    loop:
        name = input("主人公の名前を入力してください: ")
        if name.strip() != "":
            hero_name = name.strip()
            break
        else:
            「名前は1文字以上で入力してください。」を表示
    ```
    

    クラス図(CLASS.md)」

    # CLASS.md
    
    ## 概要
    `rpg.py` は1ファイル・クラスなしの手続き型実装を採用する。  
    関数分割のみで責務を分離する。
    
    ---
    
    ## 設計方針
    - クラスは不使用(高校生向けシンプルな構成)
    - `scores` は `main()` で初期化し、全シーン関数に引数として渡す
    - 各フェーズを独立した関数として定義し、可読性を確保する
    
    ## 表示文ポリシー
    - 各シーン説明文とエンディング文には `hero_name` を必ず含める
    - 高校生向けに平易な文体を使う
    - 暴力・グロテスクな表現は避ける
    - プレイ時間は 5〜10 分程度を目安にする
    - 仲間名は固定定数 `ALLY_NAME = "レオ"` で扱う
    
    ---
    
    ## 定数
    
    ```python
    ALLY_NAME = "レオ"  # シーン2で登場する仲間の名前(固定)
    ```
    
    ---
    
    ## スコア構造
    
    `main()` で初期化し、各シーン関数に渡して更新する:
    
    ```python
    scores = {
        "brave_count": 0,       # 勇敢な選択の回数(最大3)
        "escape_count": 0,      # 逃げた選択の回数(最大3)※記録のみ、エンディング判定には不使用
        "help_friend": False,   # シーン2で仲間を助けたか
        "sacrifice": False,     # シーン3で自己犠牲を選んだか
    }
    ```
    
    ---
    
    ## 関数一覧
    
    ### `main()`
    - **責務**: ゲーム全体の進行を管理するエントリポイント
    - **処理**:
      ```python
      def main():
          show_title()
          hero_name = get_hero_name()
          print(f"{hero_name}の冒険が始まる!\n")
          scores = {
              "brave_count": 0,
              "escape_count": 0,
              "help_friend": False,
              "sacrifice": False,
          }
          scores = scene_1(hero_name, scores)
          scores = scene_2(hero_name, scores)
          scores = scene_3(hero_name, scores)
          show_ending(hero_name, scores)
      ```
    - **引数**: なし
    - **戻り値**: なし
    
    ---
    
    ### `show_title()`
    - **責務**: タイトルとプロローグを表示する
    - **引数**: なし
    - **戻り値**: なし
    - **出力例**:
      ```
      ========================================
           魔王の洞窟へ ~勇者の選択~
      ========================================
      (固定のプロローグテキスト)
      ```
    
    ---
    
    ### `get_hero_name() -> str`
    - **責務**: 主人公名を入力させ、有効な名前(strip済み非空文字列)を返す
    - **引数**: なし
    - **戻り値**: `str`(`name.strip()` 済みの非空文字列)
    - **処理**:
      - `name.strip() == ""` の間ループして再入力を促す
    
    ---
    
    ### `ask_choice(prompt: str, choices: list[str]) -> int`
    - **責務**: 選択肢を表示し、有効な番号入力が得られるまでループする
    - **引数**:
      - `prompt`: 選択前に表示するシーン説明テキスト
      - `choices`: 選択肢文字列のリスト(例: `["勇気を出して進む", "一度引き返す"]`)
    - **戻り値**: 選択された番号(`int`、1始まり)
    - **処理の擬似コード**(UI.md の「本文は再表示しない」仕様を厳守):
      ```
      print(prompt)               # シーン説明(初回のみ)
      for i, c in enumerate(choices, 1):
          print(f"{i}. {c}")      # 選択肢(初回のみ)
      while True:
          raw = input("> ")
          if raw.strip() in {"1", ..., str(len(choices))}:
              return int(raw.strip())
          print("1か2を入力してください。")   # エラーと "> " のみ再表示
      ```
    
    ---
    
    ### `scene_1(hero_name: str, scores: dict) -> dict`
    - **責務**: シーン1(入り口の選択)を実行し、スコアを更新して返す
    - **引数**: `hero_name: str`, `scores: dict`
    - **戻り値**: 更新された `scores: dict`
    - **処理**:
      - `hero_name` を含む場面説明を表示
      - `ask_choice()` で「1. 勇気を出して進む / 2. 一度引き返す」を取得
      - `choice == 1`: `scores["brave_count"] += 1`
      - `choice == 2`: `scores["escape_count"] += 1`、橋渡し文を表示
    
    ---
    
    ### `scene_2(hero_name: str, scores: dict) -> dict`
    - **責務**: シーン2(仲間の危機)を実行し、スコアを更新して返す
    - **引数**: `hero_name: str`, `scores: dict`
    - **戻り値**: 更新された `scores: dict`
    - **処理**:
      - `hero_name` を含む場面説明を表示
      - `ask_choice()` で「1. 仲間を助ける / 2. 先を急ぐ」を取得
      - `choice == 1`: `scores["brave_count"] += 1`、`scores["help_friend"] = True`、救助演出を表示
      - `choice == 2`: `scores["escape_count"] += 1`、離脱文を表示
    
    ---
    
    ### `scene_3(hero_name: str, scores: dict) -> dict`
    - **責務**: シーン3(魔王との対決)を実行し、スコアを更新して返す
    - **引数**: `hero_name: str`, `scores: dict`
    - **戻り値**: 更新された `scores: dict`
    - **処理**:
      - `hero_name` を含む場面説明を表示
      - `scores["help_friend"] == True` のとき `ALLY_NAME` の合流演出を追加表示
      - `ask_choice()` で「1. 全力で戦う / 2. 自らを犠牲にして封印する」を取得
      - `choice == 1`: `scores["brave_count"] += 1`
      - `choice == 2`: `scores["sacrifice"] = True`
    
    ---
    
    ### `show_ending(hero_name: str, scores: dict)`
    - **責務**: スコアに基づいてエンディングを判定・表示する
    - **引数**: `hero_name: str`, `scores: dict`
    - **戻り値**: なし
    - **エンディング判定**:
      ```python
      if scores["sacrifice"]:
          # エンディングC(自己犠牲の英雄)
      elif scores["brave_count"] >= 2:
          # エンディングA(勝利)
      else:
          # エンディングB(逃走・消極的結末)
      ```
    - **出力**: `hero_name` を含むエンディングテキスト + 「THE END」
    
    ---
    
    ## ファイル構成
    
    ```
    rpg.py
      ├── ALLY_NAME = "レオ"
      ├── show_title()
      ├── get_hero_name()
      ├── ask_choice()
      ├── scene_1()
      ├── scene_2()
      ├── scene_3()
      ├── show_ending()
      └── main()
    
    if __name__ == "__main__":
        main()
    ```
    

    画面(UI.md)

    # UI.md
    
    ## 概要
    ターミナル上のテキスト表示仕様を定義する。  
    本文表示は標準出力(`print()`)で行い、入力受付は `input()` を使用する。  
    本書の `_` はカーソル位置を示す記号であり、実際には表示しない。
    
    ---
    
    ## 画面遷移フロー
    
    ```
    [タイトル画面] → [主人公名入力] → [シーン1] → [シーン2] → [シーン3] → [エンディング]
    ```
    
    ---
    
    ## 各画面の表示仕様
    
    ### タイトル画面
    ```
    ========================================
         魔王の洞窟へ ~勇者の選択~
    ========================================
    
    むかし、小さな村に勇者の卵がいた。
    その名を……君が決める。
    
    ある日、村の北にある「魔王の洞窟」に
    魔物が増え、村人が困っている。
    村の長老が言った。
    「このままでは村のみんなが困り続けてしまう……
     誰か、洞窟の魔王を倒してくれないか」
    
    君は立ち上がることにした。
    ```
    
    ---
    
    ### 主人公名入力
    ```
    主人公の名前を入力してください: _
    ```
    - 空文字(スペースのみを含む)の場合:
      ```
      名前は1文字以上で入力してください。
      主人公の名前を入力してください: _
      ```
    - 入力確定後:
      ```
      {hero_name}の冒険が始まる!
      ```
    
    ---
    
    ### シーン1: 入り口の選択
    ```
    ========================================
    
    {hero_name}は洞窟の入り口に立った。
    洞窟の奥から怪しい気配がする。
    長老の言葉が頭をよぎる。
    
    1. 勇気を出して進む
    2. 一度引き返す
    
    > _
    ```
    - 無効入力時(本文は再表示しない):
      ```
      1か2を入力してください。
      > _
      ```
    - 選択2のとき追加表示:
      ```
      {hero_name}は一度村へ戻り、気持ちを整えた。
      そして再び洞窟へ向かう決意をした。
      ```
    
    ---
    
    ### シーン2: 仲間の危機
    ```
    ========================================
    
    洞窟の中を進むと、{hero_name}は岩の影に
    クラスメートのレオが倒れているのを発見した。
    「助けてくれ……罠にかかって動けないんだ」
    
    1. 仲間を助ける
    2. 先を急ぐ
    
    > _
    ```
    - 無効入力時(本文は再表示しない):
      ```
      1か2を入力してください。
      > _
      ```
    - 選択1のとき追加表示:
      ```
      {hero_name}はレオを助け起こした。
      レオは言った。「ありがとう。最後まで一緒に戦う!」
      ```
    - 選択2のとき追加表示:
      ```
      {hero_name}は迷いながらも先へ進んだ。
      レオの声が洞窟に響いていた……
      ```
    
    ---
    
    ### シーン3: 魔王との対決
    ```
    ========================================
    
    {hero_name}はついに魔王の間にたどり着いた。
    魔王は言った。
    「よく来た勇者よ。だが、ここから先へは進ませない!」
    ```
    - `help_friend == True` のとき追加表示:
      ```
      その時、後ろからレオが駆けつけた!
      「{hero_name}、一人じゃないぞ!」
      ```
    - `help_friend == False` のときは追加表示なし
    - 続き:
      ```
      1. 全力で戦う
      2. 自らを犠牲にして魔王を封印する
    
      > _
      ```
    - 無効入力時(本文は再表示しない):
      ```
      1か2を入力してください。
      > _
      ```
    
    ---
    
    ### エンディング画面
    
    #### エンディングA(勝利)
    ```
    ========================================
               ~ エンディングA ~
    ========================================
    
    {hero_name}は勇敢に戦い、ついに魔王を倒した!
    村に平和が戻り、{hero_name}は英雄として称えられた。
    
             *** THE END ***
    ```
    
    #### エンディングB(消極的結末)
    ```
    ========================================
               ~ エンディングB ~
    ========================================
    
    {hero_name}は迷いの末に決断が遅れ、
    魔王を止めきれなかった。
    村には不安が残り、{hero_name}は
    もっと早く動けたかもしれないと考え続けた。
    
             *** THE END ***
    ```
    
    #### エンディングC(自己犠牲の英雄)
    ```
    ========================================
               ~ エンディングC ~
    ========================================
    
    {hero_name}は自らを犠牲にして魔王を封印した。
    村に光が戻り、人々は{hero_name}の名を語り継いだ。
    「あの勇者がいなければ、今の平和はなかった」と。
    
             *** THE END ***
    ```
    
    ---
    
    ## 共通表示ルール
    
    | 要素                  | 仕様                                                   |
    |-----------------------|--------------------------------------------------------|
    | シーン区切り          | `========================================` (40文字)    |
    | 入力プロンプト        | `input("> ")` で受け取る(`>` と空白を表示)           |
    | 無効入力メッセージ    | 「1か2を入力してください。」を表示後、入力プロンプトのみ再表示 |
    | 無効入力時の本文      | 再表示しない(エラー文 + プロンプトのみ)               |
    | 行間                  | シーン冒頭・エンディング冒頭に空行1行を入れる           |
    | `hero_name` の差し込み| f文字列(`f"{hero_name}は…"`)を使う                   |
    | 仲間名                | 固定値 `ALLY_NAME = "レオ"` として実装し、f文字列で差し込む |
    

    テストケース(TESTCASE.md)」

    # TESTCASE.md
    
    ## 概要
    `rpg.py` の手動テストケース一覧。  
    全テストはターミナル上で `python rpg.py` を実行して確認する。  
    期待結果は画面表示で確認できる内容のみを記載する。
    
    ---
    
    ## TC-01: 正常起動・タイトル表示
    
    | 項目     | 内容                                    |
    |----------|-----------------------------------------|
    | 前提条件 | Python 3.x インストール済み             |
    | 操作     | `python rpg.py` を実行する              |
    | 期待結果 | `魔王の洞窟へ ~勇者の選択~` とプロローグが表示される |
    | 確認観点 | SPEC 要件「1ファイルで動く」「ターミナルで遊べる」 |
    
    ---
    
    ## TC-02: 主人公名の正常入力
    
    | 項目     | 内容                                    |
    |----------|-----------------------------------------|
    | 前提条件 | タイトル表示後                          |
    | 操作     | 「タロウ」と入力して Enter               |
    | 期待結果 | 「タロウの冒険が始まる!」が表示される  |
    
    ---
    
    ## TC-03: 主人公名・空文字入力
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | タイトル表示後                                |
    | 操作     | 何も入力せず Enter を押す                     |
    | 期待結果 | 「名前は1文字以上で入力してください。」が表示され、再度プロンプトが表示される |
    | 確認観点 | ゲームが終了しない、再入力ループが正常に動く  |
    
    ---
    
    ## TC-04: 主人公名・スペースのみ入力
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | タイトル表示後                                |
    | 操作     | スペース3文字を入力して Enter を押す          |
    | 期待結果 | TC-03 と同様に再入力を促す                    |
    | 確認観点 | `strip()` 処理により空白のみ名前が通らない    |
    
    ---
    
    ## TC-04A: 主人公名・前後空白の除去
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | タイトル表示後                                |
    | 操作     | 「  タロウ  」(前後空白あり)と入力して Enter |
    | 期待結果 | 以降の表示では「タロウ」が使われ、前後空白は残らない |
    | 確認観点 | `name.strip()` が正しく機能する               |
    
    ---
    
    ## TC-05: シーン1・無効入力
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | 主人公名入力完了後                            |
    | 操作     | 選択肢で「3」と入力する                       |
    | 期待結果 | 「1か2を入力してください。」が表示され、本文は再表示されず `> ` のみ再表示される |
    | 確認観点 | バリデーションループが正常に動く              |
    
    ---
    
    ## TC-05B: シーン2・非数値入力
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | シーン2が表示された状態                       |
    | 操作     | 「abc」と入力する                             |
    | 期待結果 | 「1か2を入力してください。」が表示され、本文は再表示されず `> ` のみ再表示される |
    | 確認観点 | バリデーションループがシーン2でも正常に動く   |
    
    ---
    
    ## TC-05C: シーン3・範囲外入力
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | シーン3が表示された状態                       |
    | 操作     | 「0」と入力する                               |
    | 期待結果 | 「1か2を入力してください。」が表示され、本文は再表示されず `> ` のみ再表示される |
    | 確認観点 | バリデーションループがシーン3でも正常に動く   |
    
    ---
    
    ## TC-06: エンディングA(勝利)のルート
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | ゲーム起動済み                                |
    | 操作     | シーン1: 1(進む)→ シーン2: 2(先を急ぐ)→ シーン3: 1(戦う) |
    | 期待結果 | エンディングA画面が表示され、「タロウは勇敢に戦い、ついに魔王を倒した!」と「*** THE END ***」が表示される |
    | 確認観点 | A/B/C のうち A のみ表示される                 |
    
    ---
    
    ## TC-07: エンディングA(別ルート: 全勝利)
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | ゲーム起動済み                                |
    | 操作     | シーン1: 1 → シーン2: 1(助ける)→ シーン3: 1(戦う) |
    | 期待結果 | エンディングA が表示される                    |
    | 確認観点 | `brave_count` が3の場合でも A が表示される    |
    
    ---
    
    ## TC-08: エンディングB(消極的結末)のルート
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | ゲーム起動済み                                |
    | 操作     | シーン1: 2(引き返す)→ シーン2: 2(先を急ぐ)→ シーン3: 1(戦う) |
    | 期待結果 | エンディングB が表示され、「迷いの末に決断が遅れ」の文言が含まれる |
    | 確認観点 | エンディングB の消極的結末テキストが正しく表示される |
    
    ---
    
    ## TC-09: エンディングC(自己犠牲)のルート
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | ゲーム起動済み                                |
    | 操作     | シーン1: 2 → シーン2: 1 → シーン3: 2(自己犠牲) |
    | 期待結果 | エンディングC が表示され、「自らを犠牲にして魔王を封印した」の文言が含まれる |
    | 確認観点 | エンディングC の自己犠牲テキストが正しく表示される |
    
    ---
    
    ## TC-10: エンディングC が A より優先されること
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | ゲーム起動済み                                |
    | 操作     | シーン1: 1(進む)→ シーン2: 1(助ける)→ シーン3: 2(自己犠牲) |
    | 期待結果 | エンディングA ではなく **エンディングC** が表示される |
    | 確認観点 | 判定優先順位(C > A > B)が正しく動作する     |
    
    ---
    
    ## TC-11: 仲間合流演出(シーン3)
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | ゲーム起動済み                                |
    | 操作     | シーン2で 1(助ける)を選択し、シーン3まで進む |
    | 期待結果 | シーン3の場面説明後に「レオが駆けつけた!」の演出が表示される |
    | 確認観点 | `help_friend == True` 時の条件分岐が正常に動く |
    
    ---
    
    ## TC-12: 仲間合流演出が出ないこと(シーン3)
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | ゲーム起動済み                                |
    | 操作     | シーン2で 2(先を急ぐ)を選択し、シーン3まで進む |
    | 期待結果 | シーン3で「レオが駆けつけた!」が表示されない |
    | 確認観点 | `help_friend == False` 時は追加表示なし       |
    
    ---
    
    ## TC-11A: シーン1で引き返した場合の橋渡し文
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | ゲーム起動済み                                |
    | 操作     | シーン1で「2」(引き返す)を選ぶ              |
    | 期待結果 | 「タロウは一度村へ戻り、気持ちを整えた。」の橋渡し文が表示された後、シーン2の本文が表示される |
    | 確認観点 | 選択2の後もシーン2へ正常に進む               |
    
    ---
    
    ## TC-13: THE END の表示
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | いずれかのエンディングが表示される            |
    | 操作     | 最後まで選択を進める                          |
    | 期待結果 | エンディング文の末尾に「*** THE END ***」が表示される |
    | 確認観点 | SPEC 要件「エンディングが分岐する」           |
    
    ---
    
    ## TC-14A: hero_name がシーン説明に反映されること
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | ゲーム起動済み                                |
    | 操作     | 名前に「テスト」と入力し、シーン1まで進む     |
    | 期待結果 | シーン1の場面説明に「テスト」が含まれる       |
    | 確認観点 | SPEC 要件「主人公の名前を入力できる」         |
    
    ---
    
    ## TC-14B: hero_name がエンディングA に反映されること
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | ゲーム起動済み                                |
    | 操作     | 名前に「テスト」と入力し、エンディングA ルートで完了 |
    | 期待結果 | エンディングA の文言に「テスト」が含まれる    |
    | 確認観点 | エンディング文に `hero_name` が差し込まれる   |
    
    ---
    
    ## TC-14C: hero_name がエンディングB/C に反映されること
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | ゲーム起動済み                                |
    | 操作     | 名前に「テスト」と入力し、それぞれB/Cルートで完了 |
    | 期待結果 | エンディングB/C の文言に「テスト」が含まれる  |
    | 確認観点 | 全エンディングで `hero_name` が差し込まれる   |
    
    ---
    
    ## TC-14D: hero_name がシーン2に反映されること
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | ゲーム起動済み                                |
    | 操作     | 名前に「テスト」と入力し、シーン2まで進む     |
    | 期待結果 | シーン2の場面説明に「テスト」が含まれる(例: 「テストは岩の影に…」) |
    | 確認観点 | UC-02 / UI シーン2                            |
    
    ---
    
    ## TC-14E: hero_name がシーン3に反映されること
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | ゲーム起動済み                                |
    | 操作     | 名前に「テスト」と入力し、シーン3まで進む     |
    | 期待結果 | シーン3の場面説明に「テスト」が含まれる(例: 「テストはついに魔王の間に…」) |
    | 確認観点 | UC-02 / UI シーン3                            |
    
    ---
    
    ## TC-15: rpg.py 単体で動作すること
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | `rpg.py` が配置されている                     |
    | 操作     | `python rpg.py` を実行し、起動から終了までプレイする |
    | 期待結果 | 追加の自作モジュールやデータファイルがなくても完走できる |
    | 確認観点 | SPEC 要件「1ファイルで動く」「ファイル名は rpg.py」 |
    
    ---
    
    ## TC-16: 選択肢が3回あること
    
    | 項目     | 内容                                          |
    |----------|-----------------------------------------------|
    | 前提条件 | ゲーム起動済み                                |
    | 操作     | ゲームを最初から最後まで進める                |
    | 期待結果 | プレイ中に選択プロンプト(`> `)が合計3回表示される |
    | 確認観点 | SPEC 要件「3回以上の選択肢を入れる」          |
    
    ---
    
    ## 静的チェック項目
    
    コードレビュー時に目視確認する項目:
    
    | チェック項目                         | 確認方法                          |
    |--------------------------------------|-----------------------------------|
    | `class` 定義がない                   | `class ` を grep して0件           |
    | 外部ライブラリを import していない    | `import` 文が標準ライブラリのみ   |
    | `ALLY_NAME = "レオ"` が固定定数      | ファイル冒頭の定数定義を確認      |
    | `if __name__ == "__main__"` で起動    | ファイル末尾の起動コードを確認    |
    

    疑問点を纏めたQAシート(QandA.md)

    # QandA.md
    
    未確定・要判断事項の一覧。暫定方針を明記済みのものも含む。
    
    ---
    
    ## Q1: 空文字入力時の挙動
    - **状況**: SPEC には空文字時の挙動の指定がない
    - **選択肢**:
      - A) 再入力を促す(ループ)
      - B) デフォルト名「勇者」を使用する
    - **暫定方針**: A(再入力)を採用。名前はストーリーへの没入に直結するため、空のまま進まない方が高校生向けゲームとして自然
    - **確認が必要な場合**: ユーザーがデフォルト名を望む場合は変更可
    
    ## Q2: エンディング数と判定の詳細
    - **状況**: SPEC は「エンディングが分岐する」と指定しているが、分岐数や条件は未指定
    - **暫定方針**: 3種類のエンディング(勝利・逃走・自己犠牲)を用意し、USECASE.md の判定ルールに従う
    - **確認が必要な場合**: エンディング数を変えたい場合は CLASS.md および SEQUENCE.md も更新が必要
    
    ## Q3: 「簡単なRPG」の定義
    - **状況**: SPEC の「簡単なRPG」がノベルゲーム寄りか戦闘ゲーム寄りか曖昧
    - **暫定方針**: 数値ステータス・戦闘計算なしのテキスト選択式アドベンチャーとして実装。「主人公として行動を選ぶ」「選択が結末に影響する」の2点をRPG要素として担保する
    - **確認が必要な場合**: HP・攻撃力などのステータスを加えたい場合は CLASS.md を再設計が必要
    

    ここまで全て自動生成しました。48分18秒止まらずに動きました。

    ✻ Cooked for 48m 18s

    実行結果

      完了報告
    
      実行した skill: spec-to-design
    
      選択理由: SPEC.md のみ存在し、設計書群が未作成だったため
    
      使用した入力ファイル: SPEC.md
    
      生成・更新したファイル:
    
      ┌─────────────┬────────────────────────────────────────────────────┐
      │  ファイル   │                        内容                        │
      ├─────────────┼────────────────────────────────────────────────────┤
      │ USECASE.md  │ 6つのユースケース、実装制約、高校生向け方針        │
      ├─────────────┼────────────────────────────────────────────────────┤
      │ SEQUENCE.md │ 処理フロー図、状態変化表、エンディング判定ロジック │
      ├─────────────┼────────────────────────────────────────────────────┤
      │ CLASS.md    │ 8関数の設計、スコア構造、ファイル構成              │
      ├─────────────┼────────────────────────────────────────────────────┤
      │ UI.md       │ 全画面テキスト仕様(タイトル〜エンディングC)      │
      ├─────────────┼────────────────────────────────────────────────────┤
      │ TESTCASE.md │ 20ケースの手動テスト + 静的チェック項目            │
      ├─────────────┼────────────────────────────────────────────────────┤
      │ QandA.md    │ 暫定判断3件(空文字処理・エンディング数・RPG定義) │
      └─────────────┴────────────────────────────────────────────────────┘
    
      各フェーズのレビューで修正した主な点:
      - エンディングBを「escape_count条件」から「else(消極的結末)」に統一
      - ask_choice() に「本文は再表示しない」擬似コードを追加
      - hero_name の strip() 正規化を USECASE / SEQUENCE / TESTCASE に横断適用
      - 仲間名を {仲間の名前} から ALLY_NAME = "レオ" 固定に統一
      - Python 3.9+ を動作要件として明記
    
      次工程の提案:
      設計書が揃ったので、rpg.py の実装に進めます。CLASS.md の関数設計 + UI.md のテキスト + SEQUENCE.md
      のフローをそのまま実装に落とせる状態です。
    
    ✻ Cooked for 48m 18s

    後は「実装して」と頼めば実装してくれます。

    ただ全自動で動かすとかなりトークンを消費するのですよね。


    画像
     
     
    猫好きプログラマ。半導体会社の技術者 Q&AサイトのQuoraでフォロワー数6000人の「ChatGPT情報交換所」を主宰する程生成AI好き ポートフォリオ https://hantani-portfolio.pages.dev/

    あなたへのおすすめ