Amazon Q Developer for CLI De GameをつくらNight でミサイルコマンドを作ってみた。



## Geminiを使ってプロンプトを検討
```
AIエージェントにゲームを開発させるにあたって最初期のビデオゲームの模倣がいいと思うんだけど、ミサイルコマンドをubuntu上で実行するpython3のスクリプトとしたらどんなプロンプトにするのがいいだろうか
```
- 作成したプロンプト
```text
# Role: Python Game Developer

# Objective:
あなたはプロのPythonゲーム開発者です。レトロアーケードゲームの名作「ミサイルコマンド」を模倣したデスクトップゲームを、Python 3とPygameライブラリを使って開発してください。

# Environment:
- OS: Ubuntu
- Language: Python 3
- Library: Pygame

# Core Specifications:
以下の仕様に厳密に従って、単一のPythonスクリプトファイルとしてコードを生成してください。

## 1. ゲームウィンドウ
- ウィンドウサイズ: 幅800ピクセル x 高さ600ピクセル
- 背景色: 黒 (`#000000`)
- 地面: 画面下部に緑色の長方形を描画する。

## 2. プレイヤーの砲台 (Bases)
- 画面下部の地面の上に、3つの砲台を均等な間隔で配置する。
- 各砲台は三角形または四角形で表現する。
- 各砲台には弾数（例: 10発）の制限があり、弾がなくなるとその砲台からは発射できなくなる。

## 3. 都市 (Cities)
- 3つの砲台の間に、合計6つの都市を配置する。
- 都市は小さな四角形で表現する。
- 都市は健在な状態（例: 青色）と破壊された状態（例: 灰色）を持つ。

## 4. 照準 (Crosshair)
- マウスカーソルの位置に、十字のマーク（クロスヘア）を描画する。マウスの動きに追従させること。

## 5. 敵ミサイル (Enemy Missiles)
- 画面の上部からランダムなX座標で出現する。
- 各敵ミサイルは、地上にある6つの都市または3つの砲台の中から、ランダムに1つを目標として設定する。
- 細い線として軌跡を描きながら、目標に向かって一定速度で落下する。
- 時間経過やステージクリアに応じて、落下速度と出現頻度を少しずつ上昇させる。

## 6. 迎撃ミサイル (Player Missiles)
- プレイヤーがマウスの左ボタンをクリックすると発射される。
- クリックされた照準の位置に最も近い、弾が残っている砲台から自動的に選択されて発射される。
- 砲台から照準の位置に向かって、敵ミサイルより速い速度で飛んでいく。
- 目標地点（クリックされた位置）に到達すると爆発する。

## 7. 爆発 (Explosions)
- 迎撃ミサイルが目標地点に到達すると、円形の爆発エフェクトを生成する。
- 爆発エフェクトは、生成されてから一定時間（例: 1秒）かけて徐々に大きくなり、その後消滅する。
- この爆発エフェクトの円の中に敵ミサイルが入ると、その敵ミサイルは破壊される。

## 8. ゲームロジック
- **スコア:** 敵ミサイルを1つ破壊するごとにスコアが加算される（例: 25点）。
- **ゲームオーバー:** 6つの都市がすべて破壊された時点でゲームオーバーとする。
- **ゲームオーバー表示:** ゲームオーバー時には、画面中央に "GAME OVER" と表示し、最終スコアを表示する。
- **リスタート:** ゲームオーバー画面で特定のキー（例: 'R'キー）を押すと、ゲームが初期状態に戻り、再スタートできるようにする。

# Code Requirements:
- 全てのロジックを単一の `missile_command.py` というファイルに記述してください。
- オブジェクト指向プログラミングの原則に従い、以下のクラスを使用してください:
  - `Game`: ゲーム全体の管理（ゲームループ、イベント処理、状態管理など）
  - `Base`: プレイヤーの砲台
  - `City`: 都市
  - `EnemyMissile`: 敵ミサイル
  - `PlayerMissile`: 迎撃ミサイル
  - `Explosion`: 爆発エフェクト
- 色、画面サイズ、速度などの設定値は、コードの先頭で定数としてまとめて定義してください。
- コードには、各クラスや関数の役割を説明する適切なコメントを加えてください。

# Execution Instructions:
- 最後に、このスクリプトを実行するために必要なPygameのインストールコマンドと、実行コマンドをコメントとして記載してください。
```

## amazon q developper に開発依頼

- 出来上がったソース
```missile_command.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Missile Command Game (Version 2)
A recreation of the classic arcade game using Python and Pygame.
Added wave-based gameplay with increasing difficulty.

Installation:
    pip install pygame

Run:
    python missile_command.py
"""

import pygame
import sys
import random
import math
from typing import List, Tuple, Optional

# Initialize pygame
pygame.init()

# Constants
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
FPS = 60

# Colors
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
YELLOW = (255, 255, 0)
GRAY = (128, 128, 128)
ORANGE = (255, 165, 0)
CYAN = (0, 255, 255)
PURPLE = (128, 0, 128)

# Game settings
GROUND_HEIGHT = 30
BASE_WIDTH = 30
BASE_HEIGHT = 20
CITY_WIDTH = 20
CITY_HEIGHT = 15
MISSILE_SPEED = 5
ENEMY_MISSILE_SPEED_INITIAL = 0.5
ENEMY_MISSILE_SPAWN_RATE_INITIAL = 2500  # milliseconds
ENEMY_MISSILE_SIZE = 5
EXPLOSION_MAX_RADIUS = 30
EXPLOSION_GROWTH_RATE = 0.5
EXPLOSION_DURATION = 1000  # milliseconds
MISSILES_PER_BASE = 10
SCORE_PER_HIT = 25
MISSILES_PER_WAVE = 20  # 各ウェーブの隕石数
SPEED_INCREASE_PER_WAVE = 0.1  # ウェーブごとの速度増加


class Base:
    """Player's missile base that can fire interceptor missiles."""

    def __init__(self, x: int, y: int):
        self.x = x
        self.y = y
        self.width = BASE_WIDTH
        self.height = BASE_HEIGHT
        self.missiles_left = MISSILES_PER_BASE
        self.destroyed = False

    def draw(self, screen):
        """Draw the base on the screen."""
        if not self.destroyed:
            # Draw a triangle for the base
            pygame.draw.polygon(screen, GREEN, [
                (self.x - self.width // 2, self.y),
                (self.x + self.width // 2, self.y),
                (self.x, self.y - self.height)
            ])

            # Draw missile count
            font = pygame.font.SysFont(None, 20)
            text = font.render(str(self.missiles_left), True, WHITE)
            screen.blit(text, (self.x - 5, self.y + 5))

    def fire_missile(self) -> bool:
        """Attempt to fire a missile from this base."""
        if self.missiles_left > 0 and not self.destroyed:
            self.missiles_left -= 1
            return True
        return False

    def refill_missiles(self):
        """Refill missiles at the end of a wave."""
        if not self.destroyed:
            self.missiles_left = MISSILES_PER_BASE


class City:
    """A city that needs to be protected from enemy missiles."""

    def __init__(self, x: int, y: int):
        self.x = x
        self.y = y
        self.width = CITY_WIDTH
        self.height = CITY_HEIGHT
        self.destroyed = False

    def draw(self, screen):
        """Draw the city on the screen."""
        color = GRAY if self.destroyed else BLUE
        pygame.draw.rect(screen, color,
                        (self.x - self.width // 2,
                         self.y - self.height,
                         self.width,
                         self.height))


class EnemyMissile:
    """Enemy missile that targets cities or bases."""

    def __init__(self, target_x: int, target_y: int, speed: float):
        # Start from a random position at the top of the screen
        self.start_x = random.randint(0, SCREEN_WIDTH)
        self.start_y = 0
        self.x = self.start_x
        self.y = self.start_y
        self.target_x = target_x
        self.target_y = target_y
        self.speed = speed
        self.destroyed = False

        # Calculate direction vector
        dx = self.target_x - self.start_x
        dy = self.target_y - self.start_y
        distance = math.sqrt(dx * dx + dy * dy)
        self.dx = dx / distance * self.speed
        self.dy = dy / distance * self.speed

        # Trail points
        self.trail = [(self.x, self.y)]

    def update(self):
        """Update the missile position."""
        if not self.destroyed:
            self.x += self.dx
            self.y += self.dy
            self.trail.append((self.x, self.y))
            # Keep only the last 10 positions for the trail
            if len(self.trail) > 10:
                self.trail.pop(0)

    def draw(self, screen):
        """Draw the missile and its trail on the screen."""
        if not self.destroyed:
            # Draw the trail
            if len(self.trail) > 1:
                pygame.draw.lines(screen, RED, False, self.trail, 2)

            # Draw the missile head (隕石を大きくする)
            pygame.draw.circle(screen, ORANGE, (int(self.x), int(self.y)), ENEMY_MISSILE_SIZE)
            # 隕石の内側を描画して立体感を出す
            pygame.draw.circle(screen, RED, (int(self.x), int(self.y)), ENEMY_MISSILE_SIZE - 2)

    def has_reached_target(self) -> bool:
        """Check if the missile has reached its target."""
        return (abs(self.x - self.target_x) < ENEMY_MISSILE_SIZE + 3 and
                abs(self.y - self.target_y) < ENEMY_MISSILE_SIZE + 3)


class PlayerMissile:
    """Player's interceptor missile."""

    def __init__(self, start_x: int, start_y: int, target_x: int, target_y: int):
        self.start_x = start_x
        self.start_y = start_y
        self.x = start_x
        self.y = start_y
        self.target_x = target_x
        self.target_y = target_y
        self.speed = MISSILE_SPEED
        self.exploded = False

        # Calculate direction vector
        dx = self.target_x - self.start_x
        dy = self.target_y - self.start_y
        distance = math.sqrt(dx * dx + dy * dy)
        self.dx = dx / distance * self.speed
        self.dy = dy / distance * self.speed

        # Trail points
        self.trail = [(self.x, self.y)]

    def update(self) -> bool:
        """Update the missile position. Returns True if reached target."""
        if not self.exploded:
            self.x += self.dx
            self.y += self.dy
            self.trail.append((self.x, self.y))
            # Keep only the last 10 positions for the trail
            if len(self.trail) > 10:
                self.trail.pop(0)

            # Check if reached target
            if (abs(self.x - self.target_x) < 5 and
                abs(self.y - self.target_y) < 5):
                self.exploded = True
                return True
        return False

    def draw(self, screen):
        """Draw the missile and its trail on the screen."""
        if not self.exploded:
            # Draw the trail
            if len(self.trail) > 1:
                pygame.draw.lines(screen, YELLOW, False, self.trail, 1)

            # Draw the missile head
            pygame.draw.circle(screen, YELLOW, (int(self.x), int(self.y)), 2)


class Explosion:
    """Explosion effect created when a player missile reaches its target."""

    def __init__(self, x: int, y: int):
        self.x = x
        self.y = y
        self.radius = 0
        self.max_radius = EXPLOSION_MAX_RADIUS + 10
        self.growth_rate = EXPLOSION_GROWTH_RATE
        self.duration = EXPLOSION_DURATION + 200
        self.start_time = pygame.time.get_ticks()
        self.finished = False

    def update(self):
        """Update the explosion state."""
        current_time = pygame.time.get_ticks()
        elapsed = current_time - self.start_time

        if elapsed < self.duration:
            # Grow the explosion
            progress = elapsed / self.duration
            self.radius = self.max_radius * min(progress * 2, 1)
            if progress > 0.5:
                # Start shrinking after half the duration
                self.radius = self.max_radius * (2 - progress * 2)
        else:
            self.finished = True

    def draw(self, screen):
        """Draw the explosion on the screen."""
        if not self.finished:
            # 爆発をより目立たせるために、外側と内側の2重の円を描画
            pygame.draw.circle(screen, YELLOW, (int(self.x), int(self.y)), int(self.radius), 2)
            pygame.draw.circle(screen, ORANGE, (int(self.x), int(self.y)), int(self.radius * 0.7), 1)

    def check_collision(self, missile_x: float, missile_y: float) -> bool:
        """Check if a missile is within the explosion radius."""
        if self.finished:
            return False

        distance = math.sqrt((missile_x - self.x) ** 2 + (missile_y - self.y) ** 2)
        return distance <= self.radius


class Game:
    """Main game class that manages the game state and logic."""

    def __init__(self):
        self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
        pygame.display.set_caption("Missile Command - Version 2")
        self.clock = pygame.time.Clock()
        self.font = pygame.font.SysFont(None, 36)
        self.small_font = pygame.font.SysFont(None, 24)

        self.reset_game()

    def reset_game(self):
        """Reset the game to its initial state."""
        self.game_over = False
        self.score = 0
        self.wave = 1
        self.enemy_missile_speed = ENEMY_MISSILE_SPEED_INITIAL
        self.enemy_missile_spawn_rate = ENEMY_MISSILE_SPAWN_RATE_INITIAL
        self.last_enemy_spawn_time = pygame.time.get_ticks()

        # Wave system
        self.missiles_in_wave = 0
        self.missiles_destroyed = 0
        self.wave_complete = False
        self.wave_message_time = 0
        self.show_wave_message = False

        # Create bases
        ground_y = SCREEN_HEIGHT - GROUND_HEIGHT
        base_positions = [SCREEN_WIDTH // 4, SCREEN_WIDTH // 2, 3 * SCREEN_WIDTH // 4]
        self.bases = [Base(x, ground_y) for x in base_positions]

        # Create cities
        city_positions = [
            SCREEN_WIDTH // 8,
            SCREEN_WIDTH // 8 * 3,
            SCREEN_WIDTH // 8 * 5,
            SCREEN_WIDTH // 8 * 7
        ]
        self.cities = [City(x, ground_y) for x in city_positions]

        # Add two more cities between bases
        self.cities.append(City(SCREEN_WIDTH // 4 + SCREEN_WIDTH // 8, ground_y))
        self.cities.append(City(3 * SCREEN_WIDTH // 4 - SCREEN_WIDTH // 8, ground_y))

        # Game objects
        self.enemy_missiles = []
        self.player_missiles = []
        self.explosions = []

        # 初期状態でミサイルを発射しないための遅延
        self.initial_delay = pygame.time.get_ticks() + 1500

    def start_new_wave(self):
        """Start a new wave with increased difficulty."""
        self.wave += 1
        self.enemy_missile_speed += SPEED_INCREASE_PER_WAVE
        self.missiles_in_wave = 0
        self.missiles_destroyed = 0
        self.wave_complete = False

        # Refill missiles for all bases
        for base in self.bases:
            base.refill_missiles()

        # Show wave message
        self.show_wave_message = True
        self.wave_message_time = pygame.time.get_ticks()

    def spawn_enemy_missile(self):
        """Spawn a new enemy missile targeting a random city or base."""
        current_time = pygame.time.get_ticks()

        # 初期遅延が終わるまでミサイルを発射しない
        if hasattr(self, 'initial_delay') and current_time < self.initial_delay:
            return

        # ウェーブメッセージ表示中は敵ミサイルを発射しない
        if self.show_wave_message:
            if current_time - self.wave_message_time > 3000:  # 3秒間表示
                self.show_wave_message = False
            return

        # ウェーブ完了時は新しいミサイルを発射しない
        if self.wave_complete:
            # すべての敵ミサイルが破壊されたか画面外に出たら次のウェーブを開始
            if len(self.enemy_missiles) == 0:
                self.start_new_wave()
            return

        # ウェーブの最大ミサイル数に達したら、それ以上発射しない
        if self.missiles_in_wave >= MISSILES_PER_WAVE:
            self.wave_complete = True
            return

        if current_time - self.last_enemy_spawn_time > self.enemy_missile_spawn_rate:
            self.last_enemy_spawn_time = current_time

            # Choose a random target (city or base)
            targets = []
            for city in self.cities:
                if not city.destroyed:
                    targets.append((city.x, city.y))

            for base in self.bases:
                if not base.destroyed:
                    targets.append((base.x, base.y))

            if targets:
                target_x, target_y = random.choice(targets)
                self.enemy_missiles.append(
                    EnemyMissile(target_x, target_y, self.enemy_missile_speed)
                )
                self.missiles_in_wave += 1

    def fire_player_missile(self, target_x: int, target_y: int):
        """Fire a player missile from the nearest available base."""
        # ウェーブメッセージ表示中は発射できない
        if self.show_wave_message:
            return

        # Find the closest base with missiles left
        available_bases = [base for base in self.bases
                          if base.missiles_left > 0 and not base.destroyed]

        if available_bases:
            # Sort bases by distance to target
            available_bases.sort(key=lambda base:
                               abs(base.x - target_x))

            closest_base = available_bases[0]
            if closest_base.fire_missile():
                self.player_missiles.append(
                    PlayerMissile(closest_base.x, closest_base.y - BASE_HEIGHT,
                                target_x, target_y)
                )

    def check_collisions(self):
        """Check for collisions between explosions and enemy missiles."""
        # Check if enemy missiles hit cities or bases
        for missile in self.enemy_missiles[:]:
            if missile.has_reached_target():
                # Check if it hit a city
                for city in self.cities:
                    if (not city.destroyed and
                        abs(missile.x - city.x) < CITY_WIDTH // 2 and
                        abs(missile.y - city.y) < CITY_HEIGHT):
                        city.destroyed = True
                        break

                # Check if it hit a base
                for base in self.bases:
                    if (not base.destroyed and
                        abs(missile.x - base.x) < BASE_WIDTH // 2 and
                        abs(missile.y - base.y) < BASE_HEIGHT):
                        base.destroyed = True
                        break

                missile.destroyed = True
                self.enemy_missiles.remove(missile)

        # Check if explosions hit enemy missiles
        for explosion in self.explosions:
            for missile in self.enemy_missiles[:]:
                if not missile.destroyed and explosion.check_collision(missile.x, missile.y):
                    missile.destroyed = True
                    self.enemy_missiles.remove(missile)
                    self.score += SCORE_PER_HIT
                    self.missiles_destroyed += 1

        # Check if all cities are destroyed
        if all(city.destroyed for city in self.cities):
            self.game_over = True

    def update(self):
        """Update the game state."""
        if not self.game_over:
            # Spawn enemy missiles
            self.spawn_enemy_missile()

            # Update enemy missiles
            for missile in self.enemy_missiles[:]:
                missile.update()
                # 画面外に出たミサイルを削除
                if missile.y > SCREEN_HEIGHT or missile.x < 0 or missile.x > SCREEN_WIDTH:
                    self.enemy_missiles.remove(missile)

            # Update player missiles
            for missile in self.player_missiles[:]:
                if missile.update():
                    # Missile reached target, create explosion
                    self.explosions.append(Explosion(missile.target_x, missile.target_y))
                    self.player_missiles.remove(missile)

            # Update explosions
            for explosion in self.explosions[:]:
                explosion.update()
                if explosion.finished:
                    self.explosions.remove(explosion)

            # Check collisions
            self.check_collisions()

    def draw(self):
        """Draw the game state to the screen."""
        # Clear the screen
        self.screen.fill(BLACK)

        # Draw ground
        pygame.draw.rect(self.screen, GREEN,
                        (0, SCREEN_HEIGHT - GROUND_HEIGHT,
                         SCREEN_WIDTH, GROUND_HEIGHT))

        # Draw bases
        for base in self.bases:
            base.draw(self.screen)

        # Draw cities
        for city in self.cities:
            city.draw(self.screen)

        # Draw enemy missiles
        for missile in self.enemy_missiles:
            missile.draw(self.screen)

        # Draw player missiles
        for missile in self.player_missiles:
            missile.draw(self.screen)

        # Draw explosions
        for explosion in self.explosions:
            explosion.draw(self.screen)

        # Draw crosshair at mouse position
        mouse_x, mouse_y = pygame.mouse.get_pos()
        # クロスヘアを大きく、目立つようにする
        pygame.draw.line(self.screen, WHITE, (mouse_x - 15, mouse_y), (mouse_x + 15, mouse_y), 2)
        pygame.draw.line(self.screen, WHITE, (mouse_x, mouse_y - 15), (mouse_x, mouse_y + 15), 2)
        pygame.draw.circle(self.screen, WHITE, (mouse_x, mouse_y), 3, 1)

        # Draw score
        score_text = self.small_font.render(f"Score: {self.score}", True, WHITE)
        self.screen.blit(score_text, (10, 10))

        # Draw wave information
        wave_text = self.small_font.render(f"Wave: {self.wave}", True, WHITE)
        self.screen.blit(wave_text, (10, 40))

        # Draw missiles remaining in wave
        if not self.wave_complete:
            missiles_text = self.small_font.render(
                f"Missiles: {self.missiles_destroyed}/{MISSILES_PER_WAVE}", True, WHITE)
        else:
            missiles_text = self.small_font.render(
                f"Wave Complete! {self.missiles_destroyed}/{MISSILES_PER_WAVE}", True, CYAN)
        self.screen.blit(missiles_text, (10, 70))

        # Draw wave message
        if self.show_wave_message:
            # Semi-transparent overlay
            overlay = pygame.Surface((SCREEN_WIDTH, 100), pygame.SRCALPHA)
            overlay.fill((0, 0, 0, 180))
            self.screen.blit(overlay, (0, SCREEN_HEIGHT // 2 - 50))

            # Wave message
            wave_msg = self.font.render(f"WAVE {self.wave}", True, CYAN)
            msg_rect = wave_msg.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2 - 20))
            self.screen.blit(wave_msg, msg_rect)

            # Speed message
            speed_msg = self.small_font.render(
                f"Enemy Speed: {self.enemy_missile_speed:.1f}", True, YELLOW)
            speed_rect = speed_msg.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2 + 20))
            self.screen.blit(speed_msg, speed_rect)

        # Draw game over screen
        if self.game_over:
            # Semi-transparent overlay
            overlay = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT), pygame.SRCALPHA)
            overlay.fill((0, 0, 0, 128))
            self.screen.blit(overlay, (0, 0))

            # Game over text
            game_over_text = self.font.render("GAME OVER", True, RED)
            text_rect = game_over_text.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2 - 70))
            self.screen.blit(game_over_text, text_rect)

            # Final score
            final_score_text = self.font.render(f"Final Score: {self.score}", True, WHITE)
            score_rect = final_score_text.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2 - 20))
            self.screen.blit(final_score_text, score_rect)

            # Wave reached
            wave_text = self.font.render(f"Waves Completed: {self.wave - 1}", True, CYAN)
            wave_rect = wave_text.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2 + 30))
            self.screen.blit(wave_text, wave_rect)

            # Restart instructions
            restart_text = self.small_font.render("Press 'R' to restart", True, WHITE)
            restart_rect = restart_text.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2 + 80))
            self.screen.blit(restart_text, restart_rect)

        # Update the display
        pygame.display.flip()

    def run(self):
        """Main game loop."""
        running = True

        while running:
            # Handle events
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False

                elif event.type == pygame.MOUSEBUTTONDOWN:
                    if event.button == 1 and not self.game_over:  # Left mouse button
                        self.fire_player_missile(event.pos[0], event.pos[1])

                elif event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_r and self.game_over:
                        self.reset_game()
                    elif event.key == pygame.K_ESCAPE:
                        running = False

            # Update game state
            self.update()

            # Draw everything
            self.draw()

            # Cap the frame rate
            self.clock.tick(FPS)

        pygame.quit()
        sys.exit()


if __name__ == "__main__":
    game = Game()
    game.run()
```

## 実行方法

### pygameをインストール
```shell
pip install pygame
```

### コマンドラインでゲームを実行
```shell
python3 missile_command.py
```

![スクリーンショット (1).png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/4110963/32bd9b59-6c08-473f-b7dc-febed03d0975.png)



## 感想

- cluade codeやchatgpt codexを普段使っていますが、amazon q developperは初めてで操作に慣れるか不安でしたが、claude codeに近い感覚で使えました。
- Bluetoothが直前で故障し、スピーカが使えなくなったためPC + Quest3 + VirtualDesktopで参加しましたが、意外と普通に作業できました