2025 年 10 月 29 日、GitHub Universe 2025 で発表された GitHub Copilot の新機能「Plan モード」。これは、開発者が実装前に仕様を整理し、確実な開発計画を立てるための画期的な機能です。従来の「コードを書きながら考える」スタイルから「計画を立ててから実装する」スタイルへ、開発プロセスそのものを変える可能性を秘めています。

本記事では、この Plan モードの機能詳細から使い方、他のモードとの違い、そして実際の活用方法まで、初心者の方にもわかりやすく解説していきます。

背景

AI コーディング支援ツールの進化

近年、GitHub Copilot をはじめとする AI コーディング支援ツールは、開発者の生産性を飛躍的に向上させてきました。コード補完、リファクタリング、バグ修正など、さまざまな場面で AI が開発者をサポートしています。

しかし、従来の AI 支援は主に「コーディング作業そのもの」に焦点が当てられており、実装前の「設計」や「仕様策定」の段階では、まだ人間の力に大きく依存していました。

開発プロセスにおける課題

多くの開発プロジェクトでは、以下のような課題が存在します。

• 実装前の仕様が曖昧なまま開発を始めてしまう
• 既存コードの構造を十分に理解せず、不整合なコードを追加してしまう
• 実装途中で仕様の不備に気づき、大きな手戻りが発生する
• チーム内で実装方針の認識がずれてしまう

これらの課題は、特に大規模なプロジェクトや複数人で開発する場合に深刻になります。

Plan モード登場の背景

こうした課題に対応するため、GitHub は開発プロセスの「上流工程」を AI で支援する Plan モードを開発しました。この機能は VS Code Insiders で利用可能となり、開発者がコードを書く前に、しっかりとした計画を立てられるようになりました。

以下の図は、従来の開発フローと Plan モードを活用した開発フローの違いを示しています。

mermaidCopy codeflowchart LR
    traditional_start["従来:<br/>アイデア"] -->|直接実装| traditional_code["コーディング"]
    traditional_code -->|問題発見| traditional_fix["手戻り・修正"]
    traditional_fix -->|再実装| traditional_code

    plan_start["Plan モード:<br/>アイデア"] -->|分析・計画| plan_mode["Plan モード<br/>仕様策定"]
    plan_mode -->|承認後| plan_code["コーディング"]
    plan_code -->|スムーズ| plan_done["完成"]

    style plan_mode fill:#e1f5e1
    style plan_done fill:#c8e6c9
    style traditional_fix fill:#ffcccc

図で理解できる要点:

• 従来の開発では実装後に問題が発覚し、手戻りが発生しやすい
• Plan モードを使うと事前に仕様を固めることで、スムーズな実装が可能になる
• 計画段階で問題を洗い出すことで、開発全体の効率が向上する

課題

既存の AI 支援ツールの限界

GitHub Copilot には既に Ask モード、Edit モード、Agent モードといった機能が存在していましたが、それぞれ以下のような特性がありました。

#	モード	主な機能	課題
1	Ask モード	質問や相談に対応	具体的な実装計画は作成しない
2	Edit モード	コードの編集を実行	既にコードが存在する前提
3	Agent モード	自律的にタスクを実行	事前の計画フェーズがない

これらのモードは「実装段階」や「実装後の改善」には強力ですが、実装前の仕様策定や計画立案という段階をカバーできていませんでした。

仕様の曖昧さによる問題

開発現場では、以下のような問題が頻繁に発生します。

エラー例: 仕様不明確による型エラー

typescriptCopy code// 開発者 A が実装したコード
interface User {
  id: string;
  name: string;
}

function getUser(id: string): User {
  // 実装...
}

typescriptCopy code// 開発者 B が別の想定で実装したコード
interface User {
  id: number; // string ではなく number を想定
  name: string;
  email: string; // 追加フィールド
}

// TypeError: Type 'string' is not assignable to type 'number'
const user = getUser('123');

エラーコード: TypeError: Type 'string' is not assignable to type 'number'

このような型の不整合は、事前に仕様を明確にしておけば防げた問題です。

既存コードとの整合性

新しい機能を追加する際、既存のコードベースの構造を理解せずに実装すると、以下のような問題が発生します。

• コーディングスタイルの不統一
• 重複した機能の実装
• アーキテクチャパターンの不整合
• 命名規則の不一致

これらは、プロジェクトが大きくなるほど深刻な問題となり、保守性を著しく低下させてしまいます。

以下の図は、計画なしで実装を進めた場合の問題を示しています。

mermaidCopy codeflowchart TD
    req["要件:<br/>ユーザー認証機能"] --> dev_a["開発者 A の実装"]
    req --> dev_b["開発者 B の実装"]

    dev_a --> impl_a["JWT 認証<br/>id: string<br/>REST API"]
    dev_b --> impl_b["Session 認証<br/>id: number<br/>GraphQL"]

    impl_a --> conflict["型の不整合<br/>認証方式の重複<br/>API 設計の矛盾"]
    impl_b --> conflict

    conflict --> rework["大規模な手戻り"]

    style conflict fill:#ffcccc
    style rework fill:#ff9999

図で理解できる要点:

• 同じ要件でも、仕様が明確でないと開発者ごとに異なる実装が生まれる
• 型定義、認証方式、API 設計などあらゆる面で不整合が発生する
• 結果として、大規模な手戻りが必要になり、開発コストが増大する

解決策

Plan モードとは

Plan モードは、GitHub Copilot の新しいチャットモードで、実装前の仕様策定と計画立案に特化した機能です。開発者が実装したい機能の概要を伝えると、AI が既存のコードベースを分析し、詳細な実装計画を作成してくれます。

この機能は、2025 年 10 月 28 日（米国時間）に開催された GitHub Universe 2025 で発表され、VS Code Insiders で利用可能になりました。

Plan モードの主要機能

Plan モードには、以下の 3 つの主要機能があります。

#	機能	説明	メリット
1	コードベース分析	既存コードの構造、パターン、規則を解析	一貫性のある実装が可能
2	詳細計画生成	ステップバイステップの実装計画を作成	作業の見通しが明確になる
3	要件検証	曖昧な部分を質問し、仕様を明確化	手戻りを事前に防止できる

Plan モードの動作フロー

Plan モードは、以下のようなインタラクティブなプロセスで動作します。

mermaidCopy codeflowchart TD
    start["開発者:<br/>機能の概要を入力"] --> analyze["Plan モード:<br/>既存コード分析"]
    analyze --> draft["Plan モード:<br/>初期計画の作成"]
    draft --> check{"曖昧な部分や<br/>未定義の要素<br/>はあるか?"}

    check -->|あり| question["Plan モード:<br/>開発者に質問"]
    question --> answer["開発者:<br/>質問に回答"]
    answer --> refine["Plan モード:<br/>計画を改善"]
    refine --> check

    check -->|なし| final["Plan モード:<br/>最終計画を提示"]
    final --> approve{"開発者:<br/>計画を承認?"}

    approve -->|承認| implement["実装フェーズへ<br/>(Agent/Edit モード)"]
    approve -->|修正| refine

    style analyze fill:#e3f2fd
    style question fill:#fff9c4
    style final fill:#e1f5e1
    style implement fill:#c8e6c9

図で理解できる要点:

• Plan モードは一方的に計画を提示するのではなく、対話的に仕様を明確化していく
• 開発者とのやり取りを通じて、曖昧な部分を洗い出し、計画の精度を高める
• 最終的な計画が承認されるまで、繰り返し改善を行う

他のモードとの連携

Plan モードは、他の Copilot モードと連携して使用することで、開発プロセス全体を最適化できます。

mermaidCopy codeflowchart LR
    ask["Ask モード<br/>質問・相談"] --> plan["Plan モード<br/>仕様策定・計画"]
    plan --> agent["Agent モード<br/>自律的実装"]
    agent --> edit["Edit モード<br/>コード編集"]
    edit --> review["レビュー・テスト"]

    review -->|問題発見| ask

    style plan fill:#e1f5e1
    style agent fill:#e3f2fd
    style edit fill:#fff9c4

図で理解できる要点:

• Ask モードで技術的な疑問を解消してから Plan モードで計画を立てる
• Plan モードで作成した計画を Agent モードや Edit モードで実装する
• 問題が見つかれば、再度 Ask モードで相談し、改善のサイクルを回せる

生成される計画書の構成

Plan モードが生成する計画書は、Markdown 形式で以下の要素を含みます。

概要 (Overview)

機能の簡潔な説明と目的が記載されます。

markdownCopy code# 概要

ユーザー認証機能を実装します。
JWT トークンを使用した認証システムで、
既存の REST API パターンに準拠します。

要件 (Requirements)

実装すべき機能要件が箇条書きでリストアップされます。

markdownCopy code# 要件

- ユーザー登録機能 (email, password)
- ログイン機能 (JWT トークン発行)
- トークン検証ミドルウェア
- パスワードのハッシュ化 (bcrypt 使用)
- トークンの有効期限設定 (24 時間)

実装ステップ (Implementation Steps)

具体的な実装手順が段階的に示されます。

markdownCopy code# 実装ステップ

## ステップ 1: データモデルの定義

`src/models/User.ts` に User インターフェースを定義します。
既存の `BaseModel` を継承し、プロジェクトの型規則に従います。

## ステップ 2: 認証サービスの実装

`src/services/AuthService.ts` に認証ロジックを実装します。
既存の `BaseService` パターンを踏襲します。

テスト計画 (Testing)

検証すべきテストケースが記載されます。

markdownCopy code# テスト計画

- ユーザー登録の成功ケース
- 重複メールアドレスのエラーケース
- ログイン成功・失敗ケース
- トークン検証の正常・異常ケース

具体例

実際の使用例: ユーザー認証機能の追加

ここでは、既存の Next.js プロジェクトに、ユーザー認証機能を追加する具体例を見ていきましょう。

ステップ 1: Plan モードの起動

VS Code で Copilot チャットを開き、Plan モードを選択します。

typescriptCopy code// VS Code の Copilot Chat で以下のように入力
// @workspace /plan ユーザー認証機能を追加したい。
// JWT を使った認証で、ユーザー登録とログイン機能が必要です。

Plan モードを起動すると、AI が既存のプロジェクト構造を分析し始めます。

ステップ 2: コードベースの分析

Plan モードは、プロジェクト内の以下のようなファイルを自動的に分析します。

typescriptCopy code// 分析対象の例
// - src/pages/api/*.ts (既存の API パターン)
// - src/models/*.ts (データモデルの定義方法)
// - src/lib/*.ts (ユーティリティ関数の命名規則)
// - package.json (使用中のライブラリ)

分析結果に基づいて、プロジェクトの特徴を把握します。

• TypeScript を使用
• Next.js の API Routes パターンを採用
• Prisma ORM でデータベース操作
• すでに bcrypt と jsonwebtoken がインストール済み

ステップ 3: 初期計画の提示と質問

AI が初期計画を提示した後、不明確な点について質問してきます。

markdownCopy code# AI からの質問例

以下の点について教えてください:

1. **データベース**:
   既存の Prisma スキーマに User モデルを追加しますか?
   それとも新しいスキーマファイルを作成しますか?

2. **トークンの保存場所**:
   クライアント側では JWT をどこに保存しますか?

   - localStorage
   - sessionStorage
   - httpOnly Cookie (推奨)

3. **パスワードポリシー**:
   パスワードの最小文字数や複雑さの要件はありますか?

4. **エラーハンドリング**:
   既存の API エラーハンドリングパターンに従いますか?

開発者がこれらの質問に回答することで、仕様が明確になります。

ステップ 4: 回答と計画の改善

開発者が質問に回答します。

markdownCopy code# 回答例

1. 既存の `prisma/schema.prisma` に User モデルを追加してください
2. httpOnly Cookie を使用します
3. 最小 8 文字、英数字と記号を含む
4. 既存の `src/lib/apiError.ts` のパターンに従ってください

この回答を受けて、AI は計画を改善し、より具体的な実装計画を提示します。

ステップ 5: 最終計画の確認

改善された最終計画が提示されます。以下は、その一部です。

markdownCopy code# 最終実装計画

## データモデルの定義

`prisma/schema.prisma` に以下のモデルを追加します:

prismaCopy codemodel User {
  id        String   @id @default(cuid())
  email     String   @unique
  password  String   // ハッシュ化されたパスワード
  name      String?
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

データベーススキーマに User テーブルを定義しています。email フィールドには @unique 制約を設定し、重複登録を防ぎます。

markdownCopy code## 型定義の作成

`src/types/auth.ts` に認証関連の型を定義します:

typescriptCopy code// JWT ペイロードの型定義
export interface JWTPayload {
  userId: string;
  email: string;
  iat: number; // 発行時刻
  exp: number; // 有効期限
}

// ユーザー登録リクエストの型
export interface RegisterRequest {
  email: string;
  password: string;
  name?: string;
}

// ログインリクエストの型
export interface LoginRequest {
  email: string;
  password: string;
}

// 認証レスポンスの型
export interface AuthResponse {
  user: {
    id: string;
    email: string;
    name?: string;
  };
  message: string;
}

これらの型定義により、TypeScript の型安全性を確保できます。

markdownCopy code## 認証ユーティリティの実装

`src/lib/auth.ts` に認証関連の関数を実装します:

typescriptCopy codeimport bcrypt from 'bcrypt';
import jwt from 'jsonwebtoken';
import type { JWTPayload } from '@/types/auth';

// 環境変数から JWT シークレットを取得
const JWT_SECRET =
  process.env.JWT_SECRET || 'your-secret-key';
const SALT_ROUNDS = 10;
const TOKEN_EXPIRY = '24h';

まず、必要なライブラリと定数を定義します。JWT のシークレットキーは環境変数から取得することで、セキュリティを確保しています。

typescriptCopy code/**
 * パスワードをハッシュ化する関数
 * @param password - 平文のパスワード
 * @returns ハッシュ化されたパスワード
 */
export async function hashPassword(
  password: string
): Promise<string> {
  return bcrypt.hash(password, SALT_ROUNDS);
}

/**
 * パスワードを検証する関数
 * @param password - 平文のパスワード
 * @param hashedPassword - ハッシュ化されたパスワード
 * @returns 一致すれば true
 */
export async function verifyPassword(
  password: string,
  hashedPassword: string
): Promise<boolean> {
  return bcrypt.compare(password, hashedPassword);
}

bcrypt を使用してパスワードのハッシュ化と検証を行います。SALT_ROUNDS を 10 に設定することで、適切なセキュリティレベルを保ちます。

typescriptCopy code/**
 * JWT トークンを生成する関数
 * @param payload - トークンに含めるデータ
 * @returns JWT トークン文字列
 */
export function generateToken(
  payload: Omit<JWTPayload, 'iat' | 'exp'>
): string {
  return jwt.sign(payload, JWT_SECRET, {
    expiresIn: TOKEN_EXPIRY,
  });
}

/**
 * JWT トークンを検証する関数
 * @param token - 検証する JWT トークン
 * @returns 検証成功時はペイロード、失敗時は null
 */
export function verifyToken(
  token: string
): JWTPayload | null {
  try {
    return jwt.verify(token, JWT_SECRET) as JWTPayload;
  } catch (error) {
    return null;
  }
}

JWT の生成と検証を行う関数です。トークンの有効期限は 24 時間に設定されています。

markdownCopy code## ユーザー登録 API の実装

`src/pages/api/auth/register.ts` を作成します:

typescriptCopy codeimport type { NextApiRequest, NextApiResponse } from 'next';
import { prisma } from '@/lib/prisma';
import { hashPassword } from '@/lib/auth';
import { ApiError } from '@/lib/apiError';
import type {
  RegisterRequest,
  AuthResponse,
} from '@/types/auth';

// パスワードの複雑さをチェックする関数
function validatePassword(password: string): boolean {
  // 最小8文字、英数字と記号を含む
  const minLength = password.length >= 8;
  const hasLetter = /[a-zA-Z]/.test(password);
  const hasNumber = /[0-9]/.test(password);
  const hasSymbol = /[!@#$%^&*(),.?":{}|<>]/.test(password);

  return minLength && hasLetter && hasNumber && hasSymbol;
}

パスワードポリシーを検証する関数です。指定された要件（最小 8 文字、英数字と記号を含む）を満たしているかチェックします。

typescriptCopy codeexport default async function handler(
  req: NextApiRequest,
  res: NextApiResponse<AuthResponse | { error: string }>
) {
  // POST メソッドのみ許可
  if (req.method !== 'POST') {
    return res.status(405).json({ error: 'Method Not Allowed' });
  }

  try {
    const { email, password, name } = req.body as RegisterRequest;

    // バリデーション
    if (!email || !password) {
      throw new ApiError(400, 'Email and password are required');
    }

    if (!validatePassword(password)) {
      throw new ApiError(
        400,
        'Password must be at least 8 characters and contain letters, numbers, and symbols'
      );
    }

リクエストのバリデーションを行います。必須フィールドのチェックとパスワードポリシーの検証を実施しています。

typescriptCopy code// 既存ユーザーのチェック
const existingUser = await prisma.user.findUnique({
  where: { email },
});

if (existingUser) {
  throw new ApiError(409, 'User already exists');
}

// パスワードのハッシュ化
const hashedPassword = await hashPassword(password);

メールアドレスの重複チェックを行い、既存ユーザーがいる場合は 409 Conflict エラーを返します。新規ユーザーの場合は、パスワードをハッシュ化します。

typescriptCopy code// ユーザーの作成
const user = await prisma.user.create({
  data: {
    email,
    password: hashedPassword,
    name,
  },
  // パスワードは返さない
  select: {
    id: true,
    email: true,
    name: true,
  },
});

// レスポンスを返す
res.status(201).json({
  user,
  message: 'User registered successfully',
});

Prisma を使ってデータベースにユーザーを作成します。select オプションを使用して、パスワードをレスポンスに含めないようにしています。

typescriptCopy code  } catch (error) {
    // エラーハンドリング (既存パターンに従う)
    if (error instanceof ApiError) {
      return res.status(error.statusCode).json({ error: error.message });
    }

    console.error('Registration error:', error);
    return res.status(500).json({ error: 'Internal Server Error' });
  }
}

既存の ApiError クラスを使用したエラーハンドリングです。予期しないエラーの場合は、詳細をログに記録し、500 Internal Server Error を返します。

markdownCopy code## ログイン API の実装

`src/pages/api/auth/login.ts` を作成します:

typescriptCopy codeimport type { NextApiRequest, NextApiResponse } from 'next';
import { serialize } from 'cookie';
import { prisma } from '@/lib/prisma';
import { verifyPassword, generateToken } from '@/lib/auth';
import { ApiError } from '@/lib/apiError';
import type { LoginRequest, AuthResponse } from '@/types/auth';

export default async function handler(
  req: NextApiRequest,
  res: NextApiResponse<AuthResponse | { error: string }>
) {
  if (req.method !== 'POST') {
    return res.status(405).json({ error: 'Method Not Allowed' });
  }

  try {
    const { email, password } = req.body as LoginRequest;

    // バリデーション
    if (!email || !password) {
      throw new ApiError(400, 'Email and password are required');
    }

ログイン API も同様に、POST メソッドのみを受け付け、必須フィールドをバリデーションします。

typescriptCopy code// ユーザーの取得
const user = await prisma.user.findUnique({
  where: { email },
});

// ユーザーが存在しない、またはパスワードが一致しない
if (
  !user ||
  !(await verifyPassword(password, user.password))
) {
  // セキュリティのため、詳細は明かさない
  throw new ApiError(401, 'Invalid email or password');
}

ユーザーを取得し、パスワードを検証します。セキュリティ上の理由から、エラーメッセージは「メールアドレスまたはパスワードが正しくありません」と曖昧にしています。

typescriptCopy code// JWT トークンの生成
const token = generateToken({
  userId: user.id,
  email: user.email,
});

// httpOnly Cookie にトークンを設定
const cookie = serialize('auth_token', token, {
  httpOnly: true,
  secure: process.env.NODE_ENV === 'production',
  sameSite: 'strict',
  maxAge: 60 * 60 * 24, // 24時間
  path: '/',
});

res.setHeader('Set-Cookie', cookie);

JWT トークンを生成し、httpOnly Cookie として設定します。httpOnly フラグにより、JavaScript からのアクセスを防ぎ、XSS 攻撃を防止します。

typescriptCopy code    // レスポンスを返す
    res.status(200).json({
      user: {
        id: user.id,
        email: user.email,
        name: user.name,
      },
      message: 'Login successful',
    });
  } catch (error) {
    if (error instanceof ApiError) {
      return res.status(error.statusCode).json({ error: error.message });
    }

    console.error('Login error:', error);
    return res.status(500).json({ error: 'Internal Server Error' });
  }
}

ログイン成功時は、ユーザー情報をレスポンスとして返します。パスワードは含めません。

markdownCopy code## 認証ミドルウェアの実装

`src/middleware/auth.ts` を作成します:

typescriptCopy codeimport type { NextApiRequest, NextApiResponse } from 'next';
import { verifyToken } from '@/lib/auth';
import type { JWTPayload } from '@/types/auth';

// Next.js API Request を拡張して userId を追加
export interface AuthenticatedRequest
  extends NextApiRequest {
  user?: JWTPayload;
}

type Handler = (
  req: AuthenticatedRequest,
  res: NextApiResponse
) => Promise<void> | void;

認証済みリクエストの型を定義します。user プロパティを追加することで、認証後のハンドラーでユーザー情報にアクセスできます。

typescriptCopy code/**
 * 認証ミドルウェア
 * Cookie から JWT トークンを取得し、検証する
 */
export function withAuth(handler: Handler) {
  return async (
    req: AuthenticatedRequest,
    res: NextApiResponse
  ) => {
    try {
      // Cookie からトークンを取得
      const token = req.cookies.auth_token;

      if (!token) {
        return res
          .status(401)
          .json({
            error: 'Unauthorized: No token provided',
          });
      }

      // トークンを検証
      const payload = verifyToken(token);

      if (!payload) {
        return res
          .status(401)
          .json({ error: 'Unauthorized: Invalid token' });
      }

      // リクエストにユーザー情報を追加
      req.user = payload;

      // 次のハンドラーを実行
      return handler(req, res);
    } catch (error) {
      console.error('Auth middleware error:', error);
      return res
        .status(500)
        .json({ error: 'Internal Server Error' });
    }
  };
}

認証ミドルウェアは、Cookie から JWT トークンを取得し、検証します。検証に成功すれば、ユーザー情報をリクエストに追加して、次のハンドラーに処理を渡します。

markdownCopy code## 保護された API の例

`src/pages/api/user/profile.ts` を作成します:

typescriptCopy codeimport type { NextApiResponse } from 'next';
import { prisma } from '@/lib/prisma';
import {
  withAuth,
  AuthenticatedRequest,
} from '@/middleware/auth';

async function profileHandler(
  req: AuthenticatedRequest,
  res: NextApiResponse
) {
  if (req.method !== 'GET') {
    return res
      .status(405)
      .json({ error: 'Method Not Allowed' });
  }

  try {
    // ミドルウェアで検証済みのユーザー ID を使用
    const user = await prisma.user.findUnique({
      where: { id: req.user!.userId },
      select: {
        id: true,
        email: true,
        name: true,
        createdAt: true,
      },
    });

    if (!user) {
      return res
        .status(404)
        .json({ error: 'User not found' });
    }

    res.status(200).json({ user });
  } catch (error) {
    console.error('Profile fetch error:', error);
    return res
      .status(500)
      .json({ error: 'Internal Server Error' });
  }
}

// withAuth ミドルウェアでラップしてエクスポート
export default withAuth(profileHandler);

認証が必要な API エンドポイントの例です。withAuth ミドルウェアでラップすることで、認証されたユーザーのみがアクセスできるようになります。

計画の実装への移行

Plan モードで作成された計画を承認すると、以下のように実装フェーズに移行できます。

typescriptCopy code// Copilot Chat での操作例
// Plan を承認した後、Agent モードに切り替えて実装を依頼

// @workspace /agent この計画に基づいて実装を進めてください

Agent モードが、Plan モードで作成された計画に従って、自律的にファイルを作成・編集していきます。

まとめ

GitHub Copilot の Plan モードは、開発プロセスの「設計・仕様策定」段階を AI が支援する画期的な機能です。従来のコーディング支援だけでなく、実装前の計画立案まで AI がサポートすることで、より効率的で質の高い開発が可能になりました。

Plan モードの主な利点

• 手戻りの削減: 実装前に仕様を明確化することで、大きな手戻りを防げます
• コードの一貫性: 既存コードを分析し、プロジェクトのパターンに沿った計画を作成します
• チーム協業の向上: 明確な実装計画により、チーム内の認識のずれを防げます
• 学習効果: AI との対話を通じて、設計の考え方を学ぶことができます

Plan モードの活用シーン

Plan モードは、以下のような場面で特に有効です。

• 新機能の追加前の設計レビュー
• 大規模なリファクタリングの計画立案
• チームで実装方針を統一したい場合
• 既存コードベースへの新メンバーのオンボーディング

今後の展開

Plan モードは現在 VS Code Insiders で利用可能ですが、今後の安定版リリースで、より多くの開発者が利用できるようになるでしょう。AI による開発支援は、コーディングから設計・計画まで、開発プロセス全体に広がりつつあります。

Plan モードを活用することで、より計画的で、質の高い開発を実現してみてはいかがでしょうか。

関連リンク

• GitHub Copilot in Visual Studio Code gets upgraded - GitHub Changelog
• GitHub Copilot in VS Code - Official Documentation
• VS Code、Copilot が仕様作成を支援する「Plan モード」が追加 - Publickey
• GitHub Universe 2025 - 公式サイト
• Visual Studio Code Insiders - ダウンロード
• GitHub Copilot の料金プラン