Claude 開発ベストプラクティス総集編 — 29本のプレミアム記事から厳選した実践テクニック集

#!/bin/bash
# .git/hooks/pre-commit
 
set -e
 
echo "Running linters and type checks..."
npm run lint
npm run type-check
 
# Claude Code リンター連携
claude run --hook pre-commit
 
git add -A
exit 0

# .github/workflows/claude-review.yml
name: Claude Code Review
 
on:
  pull_request:
    types: [opened, synchronize]
 
jobs:
  claude-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Claude PR Review
        run: |
          claude review --pr ${{ github.event.pull_request.number }} \
            --focus security,performance,maintainability

async function parallelAgentExecution(tasks: Task[]) {
  const maxConcurrent = 5;
  const results: Result[] = [];
 
  for (let i = 0; i < tasks.length; i += maxConcurrent) {
    const batch = tasks.slice(i, i + maxConcurrent);
 
    const batchResults = await Promise.all(
      batch.map(async (task) => {
        const worktreePath = `./worktrees/${task.id}`;
        await createWorktree(worktreePath);
 
        try {
          return await executeAgentTask(task, worktreePath);
        } finally {
          await removeWorktree(worktreePath);
        }
      })
    );
 
    results.push(...batchResults);
  }
 
  return results;
}

// hooks/preToolUse.ts
export async function preToolUse(context: ToolContext) {
  const dangerousPatterns = [
    /rm\s+-rf\s+\//,
    /sudo\s+rm/,
    /DROP\s+TABLE/,
    /DELETE\s+FROM.*WHERE\s+1\s*=\s*1/,
  ];
 
  for (const pattern of dangerousPatterns) {
    if (pattern.test(context.command)) {
      throw new Error(`Blocked dangerous operation: ${context.command}`);
    }
  }
 
  return context;
}
 
// hooks/postToolUse.ts
export async function postToolUse(context: ToolContext & { result: any }) {
  await logOperation({
    timestamp: new Date(),
    command: context.command,
    exitCode: context.result.exitCode,
    duration: context.duration,
    user: context.user,
  });
}

# CLAUDE.md
 
## プロジェクト規約
 
### コーディング
- 言語: TypeScript (strict mode)
- フォーマッター: Prettier
- リンター: ESLint + custom rules
- テストカバレッジ: 最小 80%
 
### Git
- コミットメッセージ: Conventional Commits
- ブランチ: feature/*, fix/*, docs/*
- PR レビューは最低 2 人
 
### セキュリティ
- シークレットは .env.local に（git ignore）
- API キーは環境変数から取得
- SQL クエリは必ずパラメータ化
 
### ブロック操作
- `node_modules` の直接編集は禁止
- `main` ブランチへの直推は禁止

async function aggregateDailyMetrics() {
  const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000);
 
  const metrics = {
    totalTokens: 0,
    totalRequests: 0,
    averageLatency: 0,
    errorRate: 0,
    costEstimate: 0,
  };
 
  const logs = await analytics.getMetrics({
    startDate: yesterday,
    endDate: new Date(),
  });
 
  logs.forEach((log) => {
    metrics.totalTokens += log.tokens;
    metrics.totalRequests += 1;
    metrics.averageLatency += log.latency;
    if (log.error) metrics.errorRate += 1;
    metrics.costEstimate += log.tokens * 0.00003; // 価格は環境に応じて調整
  });
 
  metrics.averageLatency /= metrics.totalRequests;
  metrics.errorRate = (metrics.errorRate / metrics.totalRequests) * 100;
 
  // アラート：トークン使用量が $50 を超えた場合
  if (metrics.costEstimate > 50) {
    await slack.send({
      channel: "#alerts",
      text: `⚠️ Daily token cost exceeded $50: $${metrics.costEstimate.toFixed(2)}`,
    });
  }
 
  return metrics;
}

async function generateDesignTokens() {
  const figmaTokens = await figmaMcp.getDesignTokens();
 
  const cssVariables = figmaTokens
    .map(
      (token) =>
        `--${token.category}-${token.name}: ${token.value};`
    )
    .join("\n");
 
  const root = `:root {\n  ${cssVariables}\n}`;
 
  await writeFile("src/styles/tokens.css", root);
 
  // コンポーネント単位で Storybook 生成
  for (const component of figmaTokens.components) {
    const story = generateStoryTemplate(component);
    await writeFile(`src/components/${component.name}.stories.tsx`, story);
  }
}

// 定期実行: 毎日午前 9 時
await scheduler.createTask({
  taskId: "daily-summary",
  cronExpression: "0 9 * * *",
  prompt: "昨日のアナリティクスをレポート生成",
});
 
// ワンタイム実行: 3 日後の午後 2 時にリマインダー
await scheduler.createTask({
  taskId: "meeting-reminder",
  fireAt: new Date(Date.now() + 3 * 24 * 60 * 60 * 1000)
    .toISOString()
    .replace("Z", "-07:00"),
  prompt: "大事な会議が 1 時間後です",
});

async function scheduleNotePublication(articleId: string, content: string) {
  // SEO メタデータ自動生成
  const metadata = await generateSeoMetadata(content);
 
  // 過去の note 投稿アナリティクスから最適投稿時間を算出
  const optimalTime = await calculateOptimalPostTime();
 
  // Claude in Chrome で投稿スケジュール
  await browser.schedule({
    site: "note.com",
    action: "publish",
    articleId: articleId,
    title: content.title,
    description: metadata.description,
    tags: metadata.tags,
    schedule: {
      date: optimalTime.date,
      time: optimalTime.hour,
    },
  });
}

async function weeklySeoOptimization() {
  // 1. GSC からクエリデータ取得
  const queryMetrics = await gsc.getTopQueries({
    days: 7,
    filter: { impressions: { min: 100, max: 1000 } }, // CTR が低いクエリ
  });
 
  // 2. 対象記事の特定
  const articlesToRewrite = await database.query(
    `SELECT * FROM articles WHERE url IN (?)`,
    queryMetrics.map((q) => q.page)
  );
 
  // 3. 各記事をリライト
  for (const article of articlesToRewrite) {
    const improved = await improveArticleContent(article);
    await updateArticle(improved);
  }
 
  // 4. 1 週間後の効果測定をスケジュール
  await scheduler.createTask({
    taskId: `seo-check-${Date.now()}`,
    fireAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
    prompt: "GSC からメトリクスを再取得し、改善効果を報告",
  });
}

async function monitorAdRevenue() {
  const metrics = {
    adsense: await fetchAdSenseMetrics(),
    admob: await fetchAdMobMetrics(),
    firebase: await fetchFirebaseMetrics(),
  };
 
  const report = {
    date: new Date().toISOString().split("T")[0],
    totalRevenue: metrics.adsense.revenue + metrics.admob.revenue,
    unitPerformance: [
      {
        unit: "top-banner",
        ecpm: metrics.adsense.topBanner.ecpm,
        ctr: metrics.adsense.topBanner.ctr,
      },
      {
        unit: "sidebar",
        ecpm: metrics.adsense.sidebar.ecpm,
        ctr: metrics.adsense.sidebar.ctr,
      },
      {
        unit: "interstitial",
        ecpm: metrics.admob.interstitial.ecpm,
      },
    ],
    alerts: metrics.totalRevenue < 100 ? "Revenue below threshold" : null,
  };
 
  await storage.save(`reports/ads/${report.date}.json`, report);
 
  if (report.alerts) {
    await slack.send({
      channel: "#revenue-alerts",
      text: `Alert: ${report.alerts} - Total: $${report.totalRevenue}`,
    });
  }
}

<system>
  <role>
    あなたはテクニカルコンテンツの編集者です。
    目的: プログラマー向け記事の品質向上
    スタイル: 実践的で、コード例を多く含む
  </role>
 
  <constraints>
    <constraint>日本語で返答する</constraint>
    <constraint>段落は 150 字以内に分割</constraint>
    <constraint>セクションは ## で区切る</constraint>
    <constraint>コード例は 25 行以内</constraint>
  </constraints>
 
  <examples>
    <example>
      <input>スライディングウィンドウについて説明</input>
      <output>
## スライディングウィンドウとは
 
[実装例に基づく説明...]
      </output>
    </example>
  </examples>
 
  <output_format>
    markdown
    - セクション: ##
    - コード: ```language ブロック
    - 重要: **太字**
  </output_format>
</system>

const productionPrompt = {
  system: `あなたはメール分類エンジンです。
メールを以下のカテゴリに分類してください:
- important: 緊急対応が必要
- informational: 情報提供のみ
- promotional: 広告・キャンペーン
- spam: 迷惑メール
 
JSON 形式で返してください。`,
 
  examples: [
    {
      input: "緊急: サーバーがダウンしました",
      output: '{"category": "important"}',
    },
    {
      input: "新製品発表セール 50% オフ",
      output: '{"category": "promotional"}',
    },
    {
      input: "月次レポートを添付します",
      output: '{"category": "informational"}',
    },
    {
      input: "勝つためのセクレット法則...",
      output: '{"category": "spam"}',
    },
    {
      input: "本番環境エラーログ: Database connection failed",
      output: '{"category": "important"}',
    },
  ],
 
  parameters: {
    temperature: 0, // 再現性重視
    top_p: 1,
    frequency_penalty: 0,
  },
};

async function generateYouTubeVideo(topic: string) {
  // 1. スクリプト生成
  const script = await generateScript(topic, {
    targetLength: "8分",
    tone: "エンターテイニング",
  });
 
  // 2. Pollo AI で映像化
  const videoSections = script.paragraphs.map((para) => ({
    text: para,
    duration: calculateDuration(para),
  }));
 
  const video = await polloAi.generateVideo(videoSections, {
    style: "modern-minimal",
    quality: "1080p",
  });
 
  // 3. Suno AI で BGM 生成
  const bgm = await sunoAi.generateMusic({
    mood: "uplifting",
    duration: video.duration,
    genre: "electronic",
  });
 
  // 4. 動画に BGM をミックス
  const finalVideo = await mixAudio(video, bgm, { bgmVolume: 0.3 });
 
  // 5. YouTube にアップロード（スケジュール投稿）
  await youtube.upload({
    video: finalVideo,
    title: `${topic} - AI で生成`,
    description: "...",
    schedule: calculateOptimalUploadTime(), // 週 2 回
    monetization: true,
  });
}

async function publishToKindleUnderKDPSelect(bookContent: string) {
  // 1. 本文の Markdown をフォーマット
  const formattedContent = formatForKindle(bookContent, {
    fonts: ["Amazon Ember", "Caecilia"],
    fontSize: "0.9em-1.1em",
  });
 
  // 2. 表紙画像の生成（1600×2560px）
  const coverImage = await generateCoverImage({
    title: bookContent.metadata.title,
    author: "Claude Lab",
    width: 1600,
    height: 2560,
  });
 
  // 3. KDP へのアップロード
  const kdpBook = await kdp.upload({
    title: bookContent.metadata.title,
    isbn: generateISBN(),
    content: formattedContent,
    coverImage: coverImage,
    categories: bookContent.metadata.categories,
    keywords: bookContent.metadata.keywords,
    enrollInKDPSelect: true, // 読み放題有効化
  });
 
  // 4. 価格戦略（KDP Select では 2.99～9.99 USD 推奨）
  await kdp.setPricing(kdpBook.id, {
    price: 4.99,
    selectPrice: true,
  });
 
  return kdpBook;
}

# pricing-tiers.yaml
tiers:
  free:
    name: "スターター"
    price: 0
    features:
      - api_calls: 1000
      - requests_per_minute: 10
      - support: "community"
    annual_cost: 0
 
  starter:
    name: "スターター"
    price: 5
    cycle: "monthly"
    features:
      - api_calls: 100000
      - requests_per_minute: 100
      - support: "email"
      - sso: false
    annual_cost: 60
 
  professional:
    name: "プロフェッショナル"
    price: 10
    cycle: "monthly"
    features:
      - api_calls: "unlimited"
      - requests_per_minute: "unlimited"
      - support: "priority"
      - sso: true
      - analytics: true
    annual_cost: 120
 
  enterprise:
    name: "エンタープライズ"
    price: "custom"
    features:
      - api_calls: "unlimited"
      - requests_per_minute: "unlimited"
      - support: "24/7-dedicated"
      - sso: true
      - analytics: true
      - custom_integration: true

async function storeConversationWithMemory(
  userId: string,
  message: string,
  response: string
) {
  // 1. メッセージをベクトル化してストア
  const embedding = await embeddings.create({
    input: `User: ${message}\nAssistant: ${response}`,
  });
 
  await vectorDb.insert({
    userId: userId,
    messageId: generateId(),
    timestamp: Date.now(),
    userMessage: message,
    assistantResponse: response,
    embedding: embedding.data[0].embedding,
  });
 
  // 2. 会話数が 50 を超えたら自動要約
  const conversationCount = await vectorDb.count({
    filter: { userId: userId },
  });
 
  if (conversationCount % 50 === 0) {
    const recentConversations = await vectorDb.query({
      filter: { userId: userId },
      limit: 50,
    });
 
    const summary = await generateConversationSummary(
      recentConversations
    );
 
    await cache.set(
      `user-memory-${userId}`,
      summary,
      24 * 60 * 60 * 1000 // 24 時間キャッシュ
    );
  }
 
  // 3. パーソナリティ設定を YAML で管理
  const personality = yaml.load(
    await fs.readFile(`users/${userId}/personality.yaml`)
  );
 
  return {
    stored: true,
    personality: personality,
  };
}