diff --git a/.github/workflows/capture.yml b/.github/workflows/capture.yml
new file mode 100644
index 0000000..4351a2c
--- /dev/null
+++ b/.github/workflows/capture.yml
@@ -0,0 +1,91 @@
+name: Capture store assets
+
+# Regenerates the CWS listing assets (5 scenes + promo tile + demo webm +
+# description.md) from the BUILT bundle entirely in CI — no local browser
+# needed: Actions tab → "Capture store assets" → Run workflow → download the
+# `store-assets` artifact. shotkit runs build:bundle first and drives the
+# shipped bundle, so a green run doubles as a real-bundle smoke test.
+
+on:
+  workflow_dispatch:
+    inputs:
+      scene:
+        description: 'Only this scene/tile/demo (comma-separated; empty = all)'
+        required: false
+        default: ''
+      video:
+        description: 'Record the demo screencast (webm)'
+        type: boolean
+        default: true
+      headless:
+        description: 'Run headless instead of under xvfb (experimental)'
+        type: boolean
+        default: false
+
+permissions:
+  contents: read
+
+jobs:
+  capture:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6.0.3
+
+      - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e  # v6.4.0
+        with:
+          node-version: 22
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      # Cache the Chromium binary so re-runs skip the ~120MB download.
+      # Same key scheme as ci.yml's e2e job.
+      - name: Cache Playwright browsers
+        id: playwright-cache
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae  # v5.0.5
+        with:
+          path: ~/.cache/ms-playwright
+          key: playwright-${{ runner.os }}-${{ hashFiles('package-lock.json') }}
+          restore-keys: |
+            playwright-${{ runner.os }}-
+
+      - name: Install xvfb (always) + Playwright Chromium (conditional)
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y xvfb
+          if [ "${{ steps.playwright-cache.outputs.cache-hit }}" != "true" ]; then
+            npx playwright install --with-deps chromium
+          else
+            npx playwright install-deps chromium
+          fi
+
+      # Inputs flow via env (never interpolated into the script) — workflow-
+      # injection-safe per GitHub's guidance.
+      - name: Capture
+        env:
+          SCENE: ${{ inputs.scene }}
+          VIDEO: ${{ inputs.video }}
+          HEADLESS: ${{ inputs.headless }}
+        run: |
+          ARGS=()
+          if [ -n "$SCENE" ]; then ARGS+=(--scene "$SCENE"); fi
+          if [ "$VIDEO" != "true" ]; then ARGS+=(--no-video); fi
+          if [ "$HEADLESS" = "true" ]; then
+            HEADED=0 npx shotkit --json "${ARGS[@]}" | tee shotkit-result.json
+          else
+            xvfb-run -a npx shotkit --json "${ARGS[@]}" | tee shotkit-result.json
+          fi
+          { echo "### shotkit assets"
+            node -e "const r=require('./shotkit-result.json'); console.log(r.produced.map(p=>'- \`'+p.split('/').pop()+'\`').join('\n'))"
+          } >> "$GITHUB_STEP_SUMMARY"
+
+      - name: Upload assets
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a  # v7.0.1
+        with:
+          name: store-assets
+          path: |
+            store-assets/*.png
+            store-assets/*.webm
+            store-assets/description.md
+          if-no-files-found: error
diff --git a/claude-plugin/skills/academy-terms/data/terms.de.json b/claude-plugin/skills/academy-terms/data/terms.de.json
index c0c5653..0a48a07 100644
--- a/claude-plugin/skills/academy-terms/data/terms.de.json
+++ b/claude-plugin/skills/academy-terms/data/terms.de.json
@@ -5,7 +5,7 @@
     "sourceVersion": "3.5.40",
     "sourceLastUpdated": "2026-04-02",
     "generatedFrom": "src/data/de.json",
-    "termCount": 999
+    "termCount": 1006
   },
   "protected": {
     "Claude Code": [
@@ -89,6 +89,13 @@
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Lernen Sie, wie Sie Sub-Agents in Claude Code verwenden und erstellen, um Kontext zu verwalten, Aufgaben zu delegieren und spezialisierte Workflows zu erstellen, die Ihre Hauptkonversation sauber und fokussiert halten.",
     "AI Capabilities and Limitations": "AI-Fähigkeiten und -Grenzen",
     "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Verstehen Sie das Verhalten moderner generativer AI-Systeme, identifizieren Sie Arten unerwarteter Ausgaben und implementieren Sie gezielte Korrekturen.",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "Dieser Kurs bringt Entwicklern von Grund auf bei, auf der Claude Developer Platform zu entwickeln — egal, ob Sie schon ein paar API-Aufrufe gemacht oder Claude bisher nur im Chat-Fenster genutzt haben.",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "Zwischen dem Chatten mit Claude im Browser-Tab und dem Einbauen von Claude in ein Produkt, das Sie ausliefern, liegt eine große Lücke. Ein Chat beantwortet eine Frage, und dort endet der Faden. Eine Anwendung schickt Claude strukturierte Anfragen, gibt ihm Werkzeuge an die Hand, lässt ihn auf echten Systemen handeln und betreibt diese Schleife für einen Nutzer oder eine Million. Die Claude Developer Platform existiert, um diese Lücke zu schließen — und das ist eine andere Fähigkeit als Prompting. Wert daraus zu ziehen heißt zu verstehen, was in einer Anfrage steckt, wie ein Agent entscheidet, was zu tun ist, und wo Kosten und Grenzen liegen.",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "Dieser Kurs bringt Entwicklern von Grund auf bei, auf der Claude Developer Platform zu entwickeln — egal, ob Sie schon ein paar API-Aufrufe gemacht oder Claude bisher nur im Chat-Fenster genutzt haben. Wir beginnen bei den Grundprinzipien: was eine API-Anfrage enthält, was eine Agenten-Schleife ist, wie das Kontextfenster begrenzt, was Claude sehen kann, und wie Werkzeuge und Berechtigungen entscheiden, was er tun darf. Die späteren Techniken des Kurses setzen sich dann als Verständnis fest statt als Liste von Aufrufen zum Abschreiben.",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "Sie senden Ihre erste Anfrage und lesen die Antwort, wählen dann das richtige Modell für die Aufgabe (Opus, Sonnet oder Haiku) und wägen den Kosten-Latenz-Kompromiss an eigenen Beispielen ab, statt zu raten. Danach bauen Sie die Agenten-Schleife von Hand, um zu sehen, wie Claude handelt, beobachtet und entscheidet — und ersetzen diese handgeschriebene Schleife durch den Tool Runner des SDK, sobald Sie verstanden haben, was er Ihnen abnimmt. Sie geben Claude über Tool-Nutzung Reichweite, lassen ihn mit Extended Thinking schwierige Probleme durchdenken und halten die Ausgaben mit Workspaces, Limits und der Console Workbench planbar.",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "Der mittlere Teil des Kurses erweitert einen Agenten über Ihren eigenen Code hinaus: Anthropics integrierte Werkzeuge (Websuche, Code-Ausführung, Web-Abruf), die auf Anthropics Infrastruktur laufen; Fähigkeiten, die einen Ablauf einmal verpacken und über Aufrufe hinweg wiederverwenden; MCP-Server, die Claude ohne Schema-Schreiben mit Drittanbieter-Werkzeugen verbinden; und die Kontext-Verwaltungsmuster, die einen langlaufenden Agenten im Fenster halten und auch nach dem zehnten Zug bezahlbar machen.",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "Der letzte Abschnitt gibt Arbeit ab. Sie lernen, wann Sie Ihre eigene Schleife betreiben und wann Sie Anthropic einen sandboxed Managed Agent für sich laufen lassen — und bauen dann einen von Anfang bis Ende, wobei Sie den Ereignisstrom konsumieren, während Anthropic die Schleife ausführt und berichtet. Eine eigenständige Lektion zeigt, wie man mit der API über Claude Code selbst entwickelt — auch deshalb zählt der Rest des Kurses: Sie müssen wissen, wie guter Code aussieht, um zu prüfen, was ein Agent für Sie schreibt. Jede Lektion endet mit einer lauffähigen Demo, sodass Sie jede mit funktionierendem Code abschließen.",
     "Meet Claude": "Treffen Sie Claude",
     "What is Claude?": "Was ist Claude?",
     "Your first conversation with Claude": "Ihr erstes Gespräch mit Claude",
diff --git a/claude-plugin/skills/academy-terms/data/terms.es.json b/claude-plugin/skills/academy-terms/data/terms.es.json
index 1c99db7..ccbee0a 100644
--- a/claude-plugin/skills/academy-terms/data/terms.es.json
+++ b/claude-plugin/skills/academy-terms/data/terms.es.json
@@ -5,7 +5,7 @@
     "sourceVersion": "3.5.40",
     "sourceLastUpdated": "2026-04-02",
     "generatedFrom": "src/data/es.json",
-    "termCount": 999
+    "termCount": 1006
   },
   "protected": {
     "Claude Code": [
@@ -92,6 +92,13 @@
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Aprende a usar y crear sub-agentes en Claude Code para gestionar el contexto, delegar tareas y construir flujos de trabajo especializados que mantengan tu conversación principal limpia y enfocada.",
     "AI Capabilities and Limitations": "Capacidades y limitaciones de AI",
     "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Comprende cómo se comportan los sistemas modernos de AI generativa, identifica tipos de resultados inesperados e implementa correcciones específicas.",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "Este curso enseña a los desarrolladores a construir sobre la Claude Developer Platform desde cero, tanto si has hecho algunas llamadas a la API como si solo has usado Claude a través de una ventana de chat.",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "Hay una gran brecha entre chatear con Claude en una pestaña del navegador y construir Claude dentro de algo que vas a lanzar. Un chat responde una pregunta y el hilo termina ahí. Una aplicación envía a Claude solicitudes estructuradas, le entrega herramientas, le permite actuar sobre sistemas reales y ejecuta ese bucle para un usuario o para un millón. La Claude Developer Platform existe para cerrar esa brecha, y es una habilidad distinta del prompting. Sacarle valor significa entender qué contiene una solicitud, cómo decide un agente qué hacer y dónde están los costos y los límites.",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "Este curso enseña a los desarrolladores a construir sobre la Claude Developer Platform desde cero, tanto si has hecho algunas llamadas a la API como si solo has usado Claude a través de una ventana de chat. Empezamos desde los primeros principios: qué contiene una solicitud a la API, qué es un bucle de agente, cómo la ventana de contexto delimita lo que Claude puede ver y cómo las herramientas y los permisos deciden lo que puede hacer. Así, las técnicas posteriores del curso se asientan como comprensión y no como una lista de llamadas para copiar.",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "Enviarás tu primera solicitud y leerás la respuesta; luego elegirás el modelo adecuado para cada tarea (Opus, Sonnet o Haiku) y sopesarás el equilibrio entre costo y latencia con tus propios ejemplos en lugar de adivinar. Después construirás el bucle del agente a mano para ver cómo Claude actúa, observa y decide, y luego lo reemplazarás con el Tool Runner del SDK una vez que entiendas lo que hace por ti. Le darás alcance a Claude mediante el uso de herramientas, le permitirás razonar problemas difíciles con el pensamiento extendido y mantendrás el gasto predecible con espacios de trabajo, límites y el Console Workbench.",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "La parte central del curso extiende el agente más allá de tu propio código: las herramientas integradas de Anthropic (búsqueda web, ejecución de código, obtención de páginas web) que corren en la infraestructura de Anthropic, las Habilidades que empaquetan un procedimiento una vez y lo reutilizan entre llamadas, los servidores MCP que conectan Claude con herramientas de terceros sin escribir un esquema, y los patrones de gestión del contexto que mantienen a un agente de larga ejecución dentro de la ventana y asequible más allá del turno diez.",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "La sección final delega el trabajo. Aprenderás cuándo ejecutar tu propio bucle y cuándo dejar que Anthropic ejecute por ti un agente gestionado y aislado en sandbox, y luego construirás uno de principio a fin, consumiendo el flujo de eventos mientras Anthropic ejecuta el bucle e informa. Una lección independiente muestra cómo construir con la API usando el propio Claude Code, que es también la razón por la que importa el resto del curso: necesitas saber cómo luce el buen código para revisar lo que un agente escribe por ti. Cada lección termina con una demo ejecutable, así que terminas cada una con código que funciona.",
     "Meet Claude": "Conoce a Claude",
     "What is Claude?": "¿Qué es Claude?",
     "Your first conversation with Claude": "Tu primera conversación con Claude",
diff --git a/claude-plugin/skills/academy-terms/data/terms.fr.json b/claude-plugin/skills/academy-terms/data/terms.fr.json
index d893e80..0c5de99 100644
--- a/claude-plugin/skills/academy-terms/data/terms.fr.json
+++ b/claude-plugin/skills/academy-terms/data/terms.fr.json
@@ -5,7 +5,7 @@
     "sourceVersion": "3.5.40",
     "sourceLastUpdated": "2026-04-02",
     "generatedFrom": "src/data/fr.json",
-    "termCount": 999
+    "termCount": 1006
   },
   "protected": {
     "Claude Code": [
@@ -89,6 +89,13 @@
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Apprenez à utiliser et créer des sub-agents dans Claude Code pour gérer le contexte, déléguer des tâches et construire des flux de travail spécialisés qui maintiennent votre conversation principale propre et ciblée.",
     "AI Capabilities and Limitations": "Capacités et limites de l'AI",
     "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Comprenez le comportement des systèmes d'AI générative modernes, identifiez les types de résultats inattendus et mettez en œuvre des correctifs ciblés.",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "Ce cours apprend aux développeurs à construire sur la Claude Developer Platform depuis la base, que vous ayez déjà fait quelques appels API ou que vous n'ayez utilisé Claude que dans une fenêtre de chat.",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "Il y a un grand écart entre discuter avec Claude dans un onglet de navigateur et intégrer Claude dans un produit que vous livrez. Un chat répond à une question et le fil s'arrête là. Une application envoie à Claude des requêtes structurées, lui confie des outils, le laisse agir sur de vrais systèmes et fait tourner cette boucle pour un utilisateur ou un million. La Claude Developer Platform existe pour combler cet écart, et c'est une compétence différente du prompting. En tirer de la valeur suppose de comprendre ce que contient une requête, comment un agent décide quoi faire, et où se situent les coûts et les limites.",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "Ce cours apprend aux développeurs à construire sur la Claude Developer Platform depuis la base, que vous ayez déjà fait quelques appels API ou que vous n'ayez utilisé Claude que dans une fenêtre de chat. Nous partons des premiers principes : ce que contient une requête API, ce qu'est une boucle d'agent, comment la fenêtre de contexte borne ce que Claude peut voir, et comment les outils et les permissions décident de ce qu'il peut faire. Les techniques abordées ensuite s'ancrent alors comme de la compréhension, et non comme une liste d'appels à recopier.",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "Vous enverrez votre première requête et lirez la réponse, puis choisirez le bon modèle pour la tâche (Opus, Sonnet ou Haiku) et évaluerez le compromis coût-latence sur vos propres exemples plutôt qu'au jugé. Vous construirez ensuite la boucle d'agent à la main pour voir comment Claude agit, observe et décide, puis vous remplacerez cette boucle artisanale par le Tool Runner du SDK une fois compris ce qu'il fait pour vous. Vous donnerez de la portée à Claude grâce à l'utilisation d'outils, le laisserez raisonner sur des problèmes difficiles avec la réflexion étendue, et garderez les dépenses prévisibles avec les espaces de travail, les limites et le Console Workbench.",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "Le milieu du cours étend l'agent au-delà de votre propre code : les outils intégrés d'Anthropic (recherche web, exécution de code, récupération de pages web) qui tournent sur l'infrastructure d'Anthropic, les Compétences qui empaquettent une procédure une fois pour la réutiliser d'un appel à l'autre, les serveurs MCP qui connectent Claude à des outils tiers sans écrire de schéma, et les schémas de gestion du contexte qui gardent un agent de longue durée dans la fenêtre et abordable au-delà du dixième tour.",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "La dernière section délègue le travail. Vous apprendrez quand faire tourner votre propre boucle et quand laisser Anthropic exécuter pour vous un agent géré dans un bac à sable, puis vous en construirez un de bout en bout, en consommant le flux d'événements pendant qu'Anthropic exécute la boucle et rend compte. Une leçon autonome montre comment construire avec l'API en utilisant Claude Code lui-même — c'est aussi pourquoi le reste du cours compte : il faut savoir à quoi ressemble du bon code pour relire ce qu'un agent écrit à votre place. Chaque leçon se termine par une démo exécutable, vous finissez donc chacune avec du code qui fonctionne.",
     "Meet Claude": "Rencontrez Claude",
     "What is Claude?": "Qu'est-ce que Claude?",
     "Your first conversation with Claude": "Votre première conversation avec Claude",
diff --git a/claude-plugin/skills/academy-terms/data/terms.it.json b/claude-plugin/skills/academy-terms/data/terms.it.json
index 617951e..80167c2 100644
--- a/claude-plugin/skills/academy-terms/data/terms.it.json
+++ b/claude-plugin/skills/academy-terms/data/terms.it.json
@@ -5,7 +5,7 @@
     "sourceVersion": "3.5.40",
     "sourceLastUpdated": "2026-06-03",
     "generatedFrom": "src/data/it.json",
-    "termCount": 999
+    "termCount": 1006
   },
   "protected": {
     "Claude Code": [
@@ -86,6 +86,13 @@
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Scopri come utilizzare e creare agenti secondari in Claude Code per gestire il contesto, delegare attività e creare flussi di lavoro specializzati che mantengono la conversazione principale pulita e mirata.",
     "AI Capabilities and Limitations": "Funzionalità e limitazioni dell'IA",
     "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Comprendi come si comportano i moderni sistemi di intelligenza artificiale generativa, identifica i tipi di output imprevisti e implementa soluzioni mirate.",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "Questo corso insegna agli sviluppatori a costruire sulla Claude Developer Platform partendo dalle basi, sia che tu abbia già fatto qualche chiamata API sia che tu abbia usato Claude solo in una finestra di chat.",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "C'è un grande divario tra chattare con Claude in una scheda del browser e integrare Claude in qualcosa che metterai in produzione. Una chat risponde a una domanda e il filo si chiude lì. Un'applicazione invia a Claude richieste strutturate, gli affida strumenti, gli permette di agire su sistemi reali ed esegue quel loop per un utente o per un milione. La Claude Developer Platform esiste per colmare quel divario, ed è una competenza diversa dal prompting. Trarne valore significa capire cosa contiene una richiesta, come un agente decide cosa fare e dove si trovano i costi e i limiti.",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "Questo corso insegna agli sviluppatori a costruire sulla Claude Developer Platform partendo dalle basi, sia che tu abbia già fatto qualche chiamata API sia che tu abbia usato Claude solo in una finestra di chat. Partiamo dai principi primi: cosa contiene una richiesta API, cos'è un loop dell'agente, come la finestra di contesto delimita ciò che Claude può vedere e come strumenti e permessi decidono ciò che può fare. Così le tecniche della parte successiva del corso si fissano come comprensione, non come un elenco di chiamate da copiare.",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "Invierai la tua prima richiesta e leggerai la risposta, poi sceglierai il modello giusto per il compito (Opus, Sonnet o Haiku) e valuterai il compromesso costo-latenza sui tuoi esempi invece di tirare a indovinare. Da lì costruirai il loop dell'agente a mano per vedere come Claude agisce, osserva e decide, poi sostituirai quel loop artigianale con il Tool Runner dell'SDK una volta capito cosa fa per te. Darai a Claude maggiore portata con l'uso degli strumenti, lo lascerai ragionare su problemi difficili con il ragionamento esteso e manterrai la spesa prevedibile con workspace, limiti e il Console Workbench.",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "La parte centrale del corso estende l'agente oltre il tuo codice: gli strumenti integrati di Anthropic (ricerca web, esecuzione di codice, recupero di pagine web) che girano sull'infrastruttura di Anthropic, le Skills che impacchettano una procedura una volta sola per riutilizzarla tra le chiamate, i server MCP che collegano Claude a strumenti di terze parti senza scrivere uno schema, e i pattern di gestione del contesto che tengono un agente a lunga esecuzione dentro la finestra e sostenibile oltre il decimo turno.",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "La sezione finale delega il lavoro. Imparerai quando eseguire il tuo loop e quando lasciare che Anthropic esegua per te un agente gestito e in sandbox, poi ne costruirai uno end-to-end, consumando il flusso di eventi mentre Anthropic esegue il loop e riferisce. Una lezione a sé mostra come costruire con l'API usando Claude Code stesso — ed è anche il motivo per cui conta il resto del corso: per rivedere il codice che un agente scrive al posto tuo devi sapere che aspetto ha il buon codice. Ogni lezione termina con una demo eseguibile, così concludi ciascuna con codice funzionante.",
     "Meet Claude": "Incontra Claude",
     "What is Claude?": "Cos'è Claude?",
     "Your first conversation with Claude": "La tua prima conversazione con Claude",
diff --git a/claude-plugin/skills/academy-terms/data/terms.ja.json b/claude-plugin/skills/academy-terms/data/terms.ja.json
index 423ceb2..a0fe824 100644
--- a/claude-plugin/skills/academy-terms/data/terms.ja.json
+++ b/claude-plugin/skills/academy-terms/data/terms.ja.json
@@ -5,7 +5,7 @@
     "sourceVersion": "3.5.40",
     "sourceLastUpdated": "2026-04-02",
     "generatedFrom": "src/data/ja.json",
-    "termCount": 999
+    "termCount": 1006
   },
   "protected": {
     "Claude Code": [
@@ -122,6 +122,13 @@
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Claude Codeでsub-agentを使用・作成して、コンテキストを管理し、タスクを委任し、メインの会話をクリーンで集中した状態に保つ専門的なワークフローを構築する方法を学びます。",
     "AI Capabilities and Limitations": "AIの能力と限界",
     "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "現代の生成AIシステムの動作を理解し、予期しない出力の種類を特定し、的を絞った修正を実装します。",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "このコースは、APIを数回呼び出したことがある方でも、チャット画面でしかClaudeを使ったことがない方でも、Claude Developer Platform上で開発する方法を基礎から教えます。",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "ブラウザのタブでClaudeとチャットすることと、Claudeを実際に出荷する製品に組み込むことの間には大きな隔たりがあります。チャットは質問に答えればそこで終わりますが、アプリケーションはClaudeに構造化されたリクエストを送り、ツールを持たせ、実際のシステムで動作させ、そのループを1人のユーザーにも100万人にも回します。Claude Developer Platformはその隔たりを埋めるために存在し、プロンプト作成とは別のスキルです。プラットフォームから価値を引き出すには、リクエストに何が含まれるか、エージェントが何をするかをどう決めるか、コストと制限がどこにあるかを理解する必要があります。",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "このコースは、APIを数回呼び出したことがある方でも、チャット画面でしかClaudeを使ったことがない方でも、Claude Developer Platform上で開発する方法を基礎から教えます。APIリクエストに何が含まれるか、エージェントループとは何か、コンテキストウィンドウがClaudeの見える範囲をどう制限するか、ツールと権限がClaudeにできることをどう決めるか — 第一原理から始めます。そうすることで、コース後半のテクニックがコピーする呼び出しのリストではなく、理解として身につきます。",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "最初のリクエストを送ってレスポンスを読み、次に仕事に合ったモデル（Opus、Sonnet、Haiku）を選び、コストとレイテンシのトレードオフを推測ではなく自分の例で見極めます。その後、エージェントループを手作りしてClaudeがどう行動し、観察し、決定するかを確かめ、その手書きループが何を肩代わりしてくれるかを理解した上でSDKのTool Runnerに置き換えます。ツール使用でClaudeの届く範囲を広げ、拡張思考で難しい問題を推論させ、ワークスペース・上限・Console Workbenchで支出を予測可能に保ちます。",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "コース中盤では、エージェントを自分のコードの外へ拡張します。Anthropicのインフラ上で実行される組み込みツール（ウェブ検索、コード実行、ウェブ取得）、手順を一度パッケージ化して呼び出しをまたいで再利用するスキル、スキーマを書かずにClaudeをサードパーティのツールにつなぐMCPサーバー、そして長時間動くエージェントをウィンドウ内に収め、10ターンを超えてもコストを抑えるコンテキスト管理パターンを扱います。",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "最後のセクションでは仕事を委ねます。いつ自分のループを回し、いつAnthropicにサンドボックス化されたManaged Agentを任せるかを学び、Anthropicがループを実行して報告するイベントストリームを消費しながら、1つをエンドツーエンドで構築します。独立したレッスンでは、Claude Code自体を使ってAPIで構築する方法を示します。これはコースの残りが重要である理由でもあります。エージェントが代わりに書いたコードをレビューするには、良いコードがどんな姿かを知っている必要があるからです。すべてのレッスンは実行可能なデモで終わるため、各レッスンを動くコードとともに終えられます。",
     "Meet Claude": "Claudeに出会う",
     "What is Claude?": "Claudeとは何ですか?",
     "Your first conversation with Claude": "Claudeとの最初の会話",
diff --git a/claude-plugin/skills/academy-terms/data/terms.ko.json b/claude-plugin/skills/academy-terms/data/terms.ko.json
index 6013ff6..d0bda91 100644
--- a/claude-plugin/skills/academy-terms/data/terms.ko.json
+++ b/claude-plugin/skills/academy-terms/data/terms.ko.json
@@ -5,7 +5,7 @@
     "sourceVersion": "3.5.40",
     "sourceLastUpdated": "2026-04-02",
     "generatedFrom": "src/data/ko.json",
-    "termCount": 999
+    "termCount": 1006
   },
   "protected": {
     "Claude Code": [
@@ -137,6 +137,13 @@
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Claude Code에서 sub-agent를 사용하고 생성하여 컨텍스트를 관리하고, 작업을 위임하고, 메인 대화를 깔끔하게 유지하는 전문화된 워크플로를 구축하는 방법을 학습합니다.",
     "AI Capabilities and Limitations": "AI의 역량과 한계",
     "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "현대 생성형 AI 시스템의 동작 방식을 이해하고, 예기치 않은 출력 유형을 식별하며, 표적화된 해결책을 적용합니다.",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "이 과정은 API 호출을 몇 번 해본 분이든 채팅 창으로만 Claude를 사용해 본 분이든, Claude Developer Platform 위에서 개발하는 방법을 기초부터 가르칩니다.",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "브라우저 탭에서 Claude와 대화하는 것과 Claude를 실제로 출시할 제품에 통합하는 것 사이에는 큰 간극이 있습니다. 채팅은 질문에 답하면 거기서 끝나지만, 애플리케이션은 Claude에 구조화된 요청을 보내고, 도구를 쥐여 주고, 실제 시스템에서 동작하게 하며, 그 루프를 한 명의 사용자든 백만 명이든 돌립니다. Claude Developer Platform은 그 간극을 메우기 위해 존재하며, 이는 프롬프트 작성과는 다른 기술입니다. 플랫폼에서 가치를 끌어내려면 요청에 무엇이 담기는지, 에이전트가 무엇을 할지 어떻게 결정하는지, 비용과 한도가 어디에 있는지 이해해야 합니다.",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "이 과정은 API 호출을 몇 번 해본 분이든 채팅 창으로만 Claude를 사용해 본 분이든, Claude Developer Platform 위에서 개발하는 방법을 기초부터 가르칩니다. API 요청에 무엇이 담기는지, 에이전트 루프란 무엇인지, 컨텍스트 윈도우가 Claude가 볼 수 있는 범위를 어떻게 한정하는지, 도구와 권한이 Claude가 할 수 있는 일을 어떻게 결정하는지 — 첫 원리부터 시작합니다. 그래야 과정 후반의 기법들이 베껴 쓸 호출 목록이 아니라 이해로 자리 잡습니다.",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "첫 요청을 보내고 응답을 읽는 것에서 시작해, 작업에 알맞은 모델(Opus, Sonnet, Haiku)을 고르고 비용·지연 트레이드오프를 추측이 아니라 직접 만든 예제로 가늠해 봅니다. 이어서 에이전트 루프를 손수 만들어 Claude가 어떻게 행동하고 관찰하고 결정하는지 본 뒤, 그 수제 루프가 무엇을 대신해 주는지 이해한 상태에서 SDK의 Tool Runner로 대체합니다. 도구 사용으로 Claude의 손이 닿는 범위를 넓히고, 확장 사고로 어려운 문제를 추론하게 하며, 워크스페이스·한도·Console Workbench로 지출을 예측 가능하게 유지합니다.",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "과정 중반에는 에이전트를 내 코드 바깥으로 확장합니다. Anthropic 인프라에서 실행되는 내장 도구(웹 검색, 코드 실행, 웹 가져오기), 절차를 한 번 패키징해 호출마다 재사용하는 Skill, 스키마를 작성하지 않고 Claude를 서드파티 도구에 연결하는 MCP 서버, 그리고 장시간 실행되는 에이전트를 윈도우 안에 머물게 하고 10턴이 지나도 비용을 감당 가능하게 하는 컨텍스트 관리 패턴을 다룹니다.",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "마지막 섹션에서는 일을 맡기는 법을 다룹니다. 언제 내 루프를 직접 돌리고 언제 Anthropic이 샌드박스화된 Managed Agent를 대신 돌리게 할지 배우고, Anthropic이 루프를 실행하며 보고하는 이벤트 스트림을 소비하면서 하나를 끝까지 만들어 봅니다. 별도 레슨에서는 Claude Code 자체로 API 기반 개발을 하는 법을 보여 주는데, 이것이 과정 전체가 중요한 이유이기도 합니다: 에이전트가 대신 써 주는 코드를 검토하려면 좋은 코드가 어떤 모습인지 알아야 하기 때문입니다. 모든 레슨은 실행 가능한 데모로 끝나므로, 각 레슨을 동작하는 코드와 함께 마치게 됩니다.",
     "Meet Claude": "Claude를 만나보세요",
     "What is Claude?": "Claude란 무엇인가요?",
     "Your first conversation with Claude": "Claude와의 첫 대화",
diff --git a/claude-plugin/skills/academy-terms/data/terms.pt-BR.json b/claude-plugin/skills/academy-terms/data/terms.pt-BR.json
index b5b8e7e..b44fc99 100644
--- a/claude-plugin/skills/academy-terms/data/terms.pt-BR.json
+++ b/claude-plugin/skills/academy-terms/data/terms.pt-BR.json
@@ -5,7 +5,7 @@
     "sourceVersion": "3.5.40",
     "sourceLastUpdated": "2026-04-02",
     "generatedFrom": "src/data/pt-BR.json",
-    "termCount": 999
+    "termCount": 1006
   },
   "protected": {
     "Claude Code": [
@@ -90,6 +90,13 @@
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Aprenda a usar e criar sub-agentes no Claude Code para gerenciar contexto, delegar tarefas e construir fluxos de trabalho especializados que mantêm sua conversa principal limpa e focada.",
     "AI Capabilities and Limitations": "Capacidades e limitações de AI",
     "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Entenda como os sistemas modernos de AI generativa se comportam, identifique tipos de resultados inesperados e implemente correções específicas.",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "Este curso ensina desenvolvedores a construir sobre a Claude Developer Platform desde o início, quer você já tenha feito algumas chamadas de API ou só tenha usado o Claude por uma janela de chat.",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "Há uma grande distância entre conversar com o Claude em uma aba do navegador e construir o Claude dentro de algo que você vai lançar. Um chat responde a uma pergunta e a conversa termina ali. Uma aplicação envia ao Claude solicitações estruturadas, entrega ferramentas a ele, permite que atue em sistemas reais e executa esse loop para um usuário ou um milhão. A Claude Developer Platform existe para fechar essa lacuna, e isso é uma habilidade diferente de prompting. Extrair valor dela significa entender o que há em uma solicitação, como um agente decide o que fazer e onde estão os custos e os limites.",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "Este curso ensina desenvolvedores a construir sobre a Claude Developer Platform desde o início, quer você já tenha feito algumas chamadas de API ou só tenha usado o Claude por uma janela de chat. Começamos pelos primeiros princípios: o que uma solicitação de API contém, o que é um loop de agente, como a janela de contexto delimita o que o Claude pode ver e como ferramentas e permissões decidem o que ele pode fazer. Assim, as técnicas da parte final do curso se firmam como compreensão, e não como uma lista de chamadas para copiar.",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "Você enviará sua primeira solicitação e lerá a resposta; depois escolherá o modelo certo para a tarefa (Opus, Sonnet ou Haiku) e pesará o equilíbrio entre custo e latência nos seus próprios exemplos, em vez de adivinhar. Em seguida, construirá o loop do agente à mão para ver como o Claude age, observa e decide, e então substituirá esse loop manual pelo Tool Runner do SDK quando entender o que ele faz por você. Você dará alcance ao Claude por meio do uso de ferramentas, deixará que ele raciocine sobre problemas difíceis com o pensamento estendido e manterá os gastos previsíveis com workspaces, limites e o Console Workbench.",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "A parte central do curso estende o agente para além do seu próprio código: as ferramentas integradas da Anthropic (busca na web, execução de código, captura de páginas) que rodam na infraestrutura da Anthropic, as Habilidades que empacotam um procedimento uma vez e o reutilizam entre chamadas, os servidores MCP que conectam o Claude a ferramentas de terceiros sem escrever um schema, e os padrões de gerenciamento de contexto que mantêm um agente de longa duração dentro da janela e acessível depois do décimo turno.",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "A seção final delega o trabalho. Você aprenderá quando executar seu próprio loop e quando deixar a Anthropic executar por você um agente gerenciado em sandbox, e então construirá um de ponta a ponta, consumindo o fluxo de eventos enquanto a Anthropic executa o loop e reporta. Uma lição independente mostra como construir com a API usando o próprio Claude Code — que é também o motivo pelo qual o resto do curso importa: você precisa saber como é um bom código para revisar o que um agente escreve por você. Cada lição termina com uma demonstração executável, então você conclui cada uma com código funcionando.",
     "Meet Claude": "Conheça o Claude",
     "What is Claude?": "O que é o Claude?",
     "Your first conversation with Claude": "Sua primeira conversa com o Claude",
diff --git a/claude-plugin/skills/academy-terms/data/terms.ru.json b/claude-plugin/skills/academy-terms/data/terms.ru.json
index 8e63e44..1151174 100644
--- a/claude-plugin/skills/academy-terms/data/terms.ru.json
+++ b/claude-plugin/skills/academy-terms/data/terms.ru.json
@@ -5,7 +5,7 @@
     "sourceVersion": "3.5.40",
     "sourceLastUpdated": "2026-04-02",
     "generatedFrom": "src/data/ru.json",
-    "termCount": 999
+    "termCount": 1006
   },
   "protected": {
     "Claude Code": [
@@ -104,6 +104,13 @@
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Узнайте, как использовать и создавать субагентов в Claude Code для управления контекстом, делегирования задач и построения специализированных рабочих процессов, которые поддерживают чистоту и фокус основного диалога.",
     "AI Capabilities and Limitations": "Возможности и ограничения ИИ",
     "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Разберитесь в поведении современных генеративных систем ИИ, определите типы неожиданных результатов и внедрите целевые исправления.",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "Этот курс учит разработчиков создавать решения на Claude Developer Platform с нуля — независимо от того, делали ли вы уже несколько вызовов API или пользовались Claude только через окно чата.",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "Между общением с Claude во вкладке браузера и встраиванием Claude в продукт, который вы выпускаете, лежит большая дистанция. Чат отвечает на вопрос — и на этом всё заканчивается. Приложение же отправляет Claude структурированные запросы, даёт ему инструменты, позволяет действовать в реальных системах и запускает этот цикл для одного пользователя или миллиона. Claude Developer Platform существует, чтобы закрыть этот разрыв, и это другой навык, нежели промптинг. Чтобы извлечь из платформы пользу, нужно понимать, что входит в запрос, как агент решает, что делать, и где находятся затраты и ограничения.",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "Этот курс учит разработчиков создавать решения на Claude Developer Platform с нуля — независимо от того, делали ли вы уже несколько вызовов API или пользовались Claude только через окно чата. Мы начинаем с первых принципов: что содержит запрос к API, что такое цикл агента, как контекстное окно ограничивает то, что видит Claude, и как инструменты и разрешения определяют, что он может делать. Тогда приёмы из дальнейшей части курса усваиваются как понимание, а не как список вызовов для копирования.",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "Вы отправите свой первый запрос и прочитаете ответ, затем подберёте подходящую модель для задачи (Opus, Sonnet или Haiku) и оцените компромисс между стоимостью и задержкой на собственных примерах, а не наугад. Далее вы соберёте цикл агента вручную, чтобы увидеть, как Claude действует, наблюдает и принимает решения, а затем замените этот самодельный цикл на Tool Runner из SDK — уже понимая, что он делает за вас. Вы расширите возможности Claude через использование инструментов, позволите ему продумывать сложные задачи в режиме расширенного размышления и сохраните расходы предсказуемыми с помощью рабочих пространств, лимитов и Console Workbench.",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "Середина курса выводит агента за пределы вашего собственного кода: встроенные инструменты Anthropic (веб-поиск, выполнение кода, загрузка веб-страниц), работающие на инфраструктуре Anthropic; навыки, которые упаковывают процедуру один раз и переиспользуют её между вызовами; серверы MCP, подключающие Claude к сторонним инструментам без написания схемы; и шаблоны управления контекстом, которые удерживают долгоживущего агента в пределах окна и делают его экономичным и после десятого хода.",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "Финальный раздел — о передаче работы. Вы узнаете, когда запускать собственный цикл, а когда позволить Anthropic запустить для вас изолированный управляемый агент, а затем соберёте такой агент целиком, потребляя поток событий, пока Anthropic выполняет цикл и отчитывается. Отдельный урок показывает, как разрабатывать с API с помощью самого Claude Code — в этом и причина важности остальной части курса: чтобы проверять код, который агент пишет за вас, нужно знать, как выглядит хороший код. Каждый урок заканчивается работающей демонстрацией, так что вы завершаете каждый с рабочим кодом.",
     "Meet Claude": "Знакомство с Claude",
     "What is Claude?": "Что такое Claude?",
     "Your first conversation with Claude": "Ваш первый разговор с Claude",
diff --git a/claude-plugin/skills/academy-terms/data/terms.vi.json b/claude-plugin/skills/academy-terms/data/terms.vi.json
index 86d69d9..0d9a0e1 100644
--- a/claude-plugin/skills/academy-terms/data/terms.vi.json
+++ b/claude-plugin/skills/academy-terms/data/terms.vi.json
@@ -5,7 +5,7 @@
     "sourceVersion": "3.5.40",
     "sourceLastUpdated": "2026-04-02",
     "generatedFrom": "src/data/vi.json",
-    "termCount": 999
+    "termCount": 1006
   },
   "protected": {
     "Claude Code": [
@@ -86,6 +86,13 @@
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Học cách sử dụng và tạo sub-agent trong Claude Code để quản lý ngữ cảnh, ủy thác tác vụ và xây dựng quy trình làm việc chuyên biệt giúp cuộc trò chuyện chính của bạn gọn gàng và tập trung.",
     "AI Capabilities and Limitations": "Năng lực và Hạn chế của AI",
     "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Hiểu cách các hệ thống AI tạo sinh hiện đại hoạt động, nhận diện các loại đầu ra không mong đợi và triển khai các bản sửa lỗi có mục tiêu.",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "Khóa học này dạy các lập trình viên xây dựng trên Claude Developer Platform từ những điều cơ bản, dù bạn đã từng gọi API vài lần hay mới chỉ dùng Claude qua cửa sổ trò chuyện.",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "Có một khoảng cách lớn giữa việc trò chuyện với Claude trong một thẻ trình duyệt và việc đưa Claude vào một sản phẩm bạn sẽ phát hành. Một cuộc chat trả lời câu hỏi rồi dừng lại ở đó. Một ứng dụng gửi cho Claude các yêu cầu có cấu trúc, trao cho nó công cụ, để nó hành động trên các hệ thống thực, và chạy vòng lặp đó cho một người dùng hay một triệu người. Claude Developer Platform tồn tại để thu hẹp khoảng cách đó, và đây là một kỹ năng khác với việc viết prompt. Khai thác giá trị từ nền tảng đòi hỏi hiểu một yêu cầu chứa gì, tác tử quyết định việc cần làm ra sao, và chi phí cùng giới hạn nằm ở đâu.",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "Khóa học này dạy các lập trình viên xây dựng trên Claude Developer Platform từ những điều cơ bản, dù bạn đã từng gọi API vài lần hay mới chỉ dùng Claude qua cửa sổ trò chuyện. Chúng ta bắt đầu từ những nguyên lý nền tảng: một yêu cầu API chứa gì, vòng lặp tác tử là gì, cửa sổ ngữ cảnh giới hạn những gì Claude thấy được ra sao, và công cụ cùng quyền hạn quyết định nó được làm gì như thế nào. Nhờ vậy, các kỹ thuật ở phần sau của khóa học đọng lại thành sự thấu hiểu thay vì một danh sách lệnh gọi để sao chép.",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "Bạn sẽ gửi yêu cầu đầu tiên và đọc phản hồi, rồi chọn mô hình phù hợp cho công việc (Opus, Sonnet hoặc Haiku) và cân nhắc đánh đổi giữa chi phí và độ trễ trên chính ví dụ của mình thay vì đoán mò. Từ đó bạn sẽ tự tay xây dựng vòng lặp tác tử để thấy Claude hành động, quan sát và quyết định ra sao, rồi thay vòng lặp viết tay đó bằng Tool Runner của SDK khi đã hiểu nó làm gì cho bạn. Bạn sẽ mở rộng tầm với của Claude qua việc sử dụng công cụ, để nó suy luận các bài toán khó với chế độ suy nghĩ mở rộng, và giữ chi tiêu trong tầm dự đoán với workspace, hạn mức và Console Workbench.",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "Phần giữa của khóa học mở rộng tác tử ra ngoài mã của riêng bạn: các công cụ tích hợp sẵn của Anthropic (tìm kiếm web, thực thi mã, truy xuất web) chạy trên hạ tầng của Anthropic, Skills đóng gói một quy trình một lần để tái sử dụng qua các lần gọi, máy chủ MCP kết nối Claude với công cụ bên thứ ba mà không cần viết schema, và các mẫu quản lý ngữ cảnh giúp tác tử chạy dài hạn ở trong cửa sổ và vẫn kham nổi chi phí sau lượt thứ mười.",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "Phần cuối bàn về việc giao việc. Bạn sẽ học khi nào tự chạy vòng lặp của mình và khi nào để Anthropic chạy giúp bạn một managed agent trong sandbox, rồi xây dựng một cái từ đầu đến cuối, tiêu thụ luồng sự kiện trong khi Anthropic chạy vòng lặp và báo cáo lại. Một bài học độc lập chỉ cách xây dựng với API bằng chính Claude Code — đó cũng là lý do phần còn lại của khóa học quan trọng: bạn cần biết mã tốt trông như thế nào để rà soát những gì tác tử viết thay bạn. Mỗi bài học kết thúc bằng một bản demo chạy được, nên bạn hoàn thành mỗi bài với mã hoạt động thực sự.",
     "Meet Claude": "Gặp gỡ Claude",
     "What is Claude?": "Claude là gì?",
     "Your first conversation with Claude": "Cuộc trò chuyện đầu tiên với Claude",
diff --git a/claude-plugin/skills/academy-terms/data/terms.zh-CN.json b/claude-plugin/skills/academy-terms/data/terms.zh-CN.json
index fe6f9d1..c26cf7c 100644
--- a/claude-plugin/skills/academy-terms/data/terms.zh-CN.json
+++ b/claude-plugin/skills/academy-terms/data/terms.zh-CN.json
@@ -5,7 +5,7 @@
     "sourceVersion": "3.5.40",
     "sourceLastUpdated": "2026-04-02",
     "generatedFrom": "src/data/zh-CN.json",
-    "termCount": 999
+    "termCount": 1006
   },
   "protected": {
     "Claude Code": [
@@ -110,6 +110,13 @@
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "学习如何在 Claude Code 中使用和创建 sub-agent 来管理上下文、委托任务，并构建保持主对话简洁专注的专业工作流。",
     "AI Capabilities and Limitations": "AI 的能力与局限性",
     "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "了解现代生成式 AI 系统的行为方式，识别意外输出的类型，并实施有针对性的修复。",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "本课程从零开始教开发者在 Claude Developer Platform 上进行构建，无论您调用过几次 API，还是只通过聊天窗口使用过 Claude。",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "在浏览器标签页里与 Claude 聊天，和把 Claude 构建进可发布的产品之间存在巨大差距。聊天回答完一个问题就结束了，而应用程序会向 Claude 发送结构化请求、交给它工具、让它在真实系统上行动，并为一个用户或一百万用户运行这个循环。Claude Developer Platform 正是为弥合这一差距而存在，这与提示词编写是不同的技能。要从中获得价值，需要理解请求中包含什么、智能体如何决定要做什么，以及成本和限制在哪里。",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "本课程从零开始教开发者在 Claude Developer Platform 上进行构建，无论您调用过几次 API，还是只通过聊天窗口使用过 Claude。我们从第一性原理出发：API 请求包含什么、什么是智能体循环、上下文窗口如何限定 Claude 能看到的范围、工具和权限如何决定它能做什么。这样课程后面的技巧就会成为真正的理解，而不是一份照抄的调用清单。",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "您将发送第一个请求并读取响应，然后为任务选择合适的模型（Opus、Sonnet 或 Haiku），用自己的示例而不是靠猜测来权衡成本与延迟。接着您将手工构建智能体循环，观察 Claude 如何行动、观察和决策，在理解 SDK 的 Tool Runner 替您做了什么之后，再用它收拢那个手写循环。您将通过工具使用扩大 Claude 的能力范围，用扩展思考让它推理难题，并通过工作区、限额和 Console Workbench 让支出保持可预测。",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "课程中段将智能体扩展到您自己的代码之外：在 Anthropic 基础设施上运行的内置工具（网页搜索、代码执行、网页抓取）、把流程打包一次即可跨调用复用的技能、无需编写 schema 就能把 Claude 连接到第三方工具的 MCP 服务器，以及让长时间运行的智能体保持在窗口之内、过了第十轮依然负担得起的上下文管理模式。",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "最后一部分是交接工作。您将学习什么时候自己运行循环、什么时候让 Anthropic 为您运行沙箱化的 Managed Agent，然后端到端构建一个，并在 Anthropic 运行循环并回报时消费事件流。一节独立课程展示如何用 Claude Code 本身来基于 API 构建——这也是课程其余部分之所以重要的原因：要审查智能体替您写的代码，您得知道好代码长什么样。每节课都以可运行的演示结尾，因此每学完一课您都会带着能跑的代码离开。",
     "Meet Claude": "认识 Claude",
     "What is Claude?": "Claude 是什么？",
     "Your first conversation with Claude": "您与 Claude 的第一次对话",
diff --git a/claude-plugin/skills/academy-terms/data/terms.zh-TW.json b/claude-plugin/skills/academy-terms/data/terms.zh-TW.json
index 351d72e..2908d81 100644
--- a/claude-plugin/skills/academy-terms/data/terms.zh-TW.json
+++ b/claude-plugin/skills/academy-terms/data/terms.zh-TW.json
@@ -5,7 +5,7 @@
     "sourceVersion": "3.5.40",
     "sourceLastUpdated": "2026-04-02",
     "generatedFrom": "src/data/zh-TW.json",
-    "termCount": 999
+    "termCount": 1006
   },
   "protected": {
     "Claude Code": [
@@ -110,6 +110,13 @@
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "學習如何在 Claude Code 中使用和建立 sub-agent 來管理上下文、委派任務，並建構保持主要對話簡潔專注的專業工作流程。",
     "AI Capabilities and Limitations": "AI 的能力與局限性",
     "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "瞭解現代生成式 AI 系統的行為方式，識別意外輸出的類型，並實施有針對性的修正。",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "本課程從零開始教開發者在 Claude Developer Platform 上進行建構，無論您呼叫過幾次 API，還是只透過聊天視窗使用過 Claude。",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "在瀏覽器分頁裡與 Claude 聊天，和把 Claude 建構進可發布的產品之間存在巨大差距。聊天回答完一個問題就結束了，而應用程式會向 Claude 發送結構化請求、交給它工具、讓它在真實系統上行動，並為一個使用者或一百萬使用者運行這個迴圈。Claude Developer Platform 正是為彌合這一差距而存在，這與提示詞編寫是不同的技能。要從中獲得價值，需要理解請求中包含什麼、智慧代理如何決定要做什麼，以及成本和限制在哪裡。",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "本課程從零開始教開發者在 Claude Developer Platform 上進行建構，無論您呼叫過幾次 API，還是只透過聊天視窗使用過 Claude。我們從第一性原理出發：API 請求包含什麼、什麼是智慧代理迴圈、上下文視窗如何限定 Claude 能看到的範圍、工具和權限如何決定它能做什麼。這樣課程後面的技巧就會成為真正的理解，而不是一份照抄的呼叫清單。",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "您將發送第一個請求並讀取回應，然後為任務選擇合適的模型（Opus、Sonnet 或 Haiku），用自己的範例而不是靠猜測來權衡成本與延遲。接著您將手工建構智慧代理迴圈，觀察 Claude 如何行動、觀察和決策，在理解 SDK 的 Tool Runner 替您做了什麼之後，再用它收攏那個手寫迴圈。您將透過工具使用擴大 Claude 的能力範圍，用延伸思考讓它推理難題，並透過工作區、限額和 Console Workbench 讓支出保持可預測。",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "課程中段將智慧代理擴充到您自己的程式碼之外：在 Anthropic 基礎設施上執行的內建工具（網頁搜尋、程式碼執行、網頁擷取）、把流程打包一次即可跨呼叫重複使用的技能、無需撰寫 schema 就能把 Claude 連接到第三方工具的 MCP 伺服器，以及讓長時間執行的智慧代理保持在視窗之內、過了第十輪依然負擔得起的上下文管理模式。",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "最後一部分是交接工作。您將學習什麼時候自己運行迴圈、什麼時候讓 Anthropic 為您運行沙箱化的 Managed Agent，然後端到端建構一個，並在 Anthropic 運行迴圈並回報時消費事件串流。一節獨立課程展示如何用 Claude Code 本身來基於 API 建構——這也是課程其餘部分之所以重要的原因：要審查智慧代理替您寫的程式碼，您得知道好程式碼長什麼樣。每節課都以可執行的示範結尾，因此每學完一課您都會帶著能跑的程式碼離開。",
     "Meet Claude": "認識 Claude",
     "What is Claude?": "Claude 是什麼？",
     "Your first conversation with Claude": "您與 Claude 的第一次對話",
diff --git a/src/data/de.json b/src/data/de.json
index 48d0daf..263bbe1 100644
--- a/src/data/de.json
+++ b/src/data/de.json
@@ -100,7 +100,14 @@
     "Introduction to subagents": "Einführung in Subagents",
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Lernen Sie, wie Sie Sub-Agents in Claude Code verwenden und erstellen, um Kontext zu verwalten, Aufgaben zu delegieren und spezialisierte Workflows zu erstellen, die Ihre Hauptkonversation sauber und fokussiert halten.",
     "AI Capabilities and Limitations": "AI-Fähigkeiten und -Grenzen",
-    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Verstehen Sie das Verhalten moderner generativer AI-Systeme, identifizieren Sie Arten unerwarteter Ausgaben und implementieren Sie gezielte Korrekturen."
+    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Verstehen Sie das Verhalten moderner generativer AI-Systeme, identifizieren Sie Arten unerwarteter Ausgaben und implementieren Sie gezielte Korrekturen.",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "Dieser Kurs bringt Entwicklern von Grund auf bei, auf der Claude Developer Platform zu entwickeln — egal, ob Sie schon ein paar API-Aufrufe gemacht oder Claude bisher nur im Chat-Fenster genutzt haben.",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "Zwischen dem Chatten mit Claude im Browser-Tab und dem Einbauen von Claude in ein Produkt, das Sie ausliefern, liegt eine große Lücke. Ein Chat beantwortet eine Frage, und dort endet der Faden. Eine Anwendung schickt Claude strukturierte Anfragen, gibt ihm Werkzeuge an die Hand, lässt ihn auf echten Systemen handeln und betreibt diese Schleife für einen Nutzer oder eine Million. Die Claude Developer Platform existiert, um diese Lücke zu schließen — und das ist eine andere Fähigkeit als Prompting. Wert daraus zu ziehen heißt zu verstehen, was in einer Anfrage steckt, wie ein Agent entscheidet, was zu tun ist, und wo Kosten und Grenzen liegen.",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "Dieser Kurs bringt Entwicklern von Grund auf bei, auf der Claude Developer Platform zu entwickeln — egal, ob Sie schon ein paar API-Aufrufe gemacht oder Claude bisher nur im Chat-Fenster genutzt haben. Wir beginnen bei den Grundprinzipien: was eine API-Anfrage enthält, was eine Agenten-Schleife ist, wie das Kontextfenster begrenzt, was Claude sehen kann, und wie Werkzeuge und Berechtigungen entscheiden, was er tun darf. Die späteren Techniken des Kurses setzen sich dann als Verständnis fest statt als Liste von Aufrufen zum Abschreiben.",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "Sie senden Ihre erste Anfrage und lesen die Antwort, wählen dann das richtige Modell für die Aufgabe (Opus, Sonnet oder Haiku) und wägen den Kosten-Latenz-Kompromiss an eigenen Beispielen ab, statt zu raten. Danach bauen Sie die Agenten-Schleife von Hand, um zu sehen, wie Claude handelt, beobachtet und entscheidet — und ersetzen diese handgeschriebene Schleife durch den Tool Runner des SDK, sobald Sie verstanden haben, was er Ihnen abnimmt. Sie geben Claude über Tool-Nutzung Reichweite, lassen ihn mit Extended Thinking schwierige Probleme durchdenken und halten die Ausgaben mit Workspaces, Limits und der Console Workbench planbar.",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "Der mittlere Teil des Kurses erweitert einen Agenten über Ihren eigenen Code hinaus: Anthropics integrierte Werkzeuge (Websuche, Code-Ausführung, Web-Abruf), die auf Anthropics Infrastruktur laufen; Fähigkeiten, die einen Ablauf einmal verpacken und über Aufrufe hinweg wiederverwenden; MCP-Server, die Claude ohne Schema-Schreiben mit Drittanbieter-Werkzeugen verbinden; und die Kontext-Verwaltungsmuster, die einen langlaufenden Agenten im Fenster halten und auch nach dem zehnten Zug bezahlbar machen.",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "Der letzte Abschnitt gibt Arbeit ab. Sie lernen, wann Sie Ihre eigene Schleife betreiben und wann Sie Anthropic einen sandboxed Managed Agent für sich laufen lassen — und bauen dann einen von Anfang bis Ende, wobei Sie den Ereignisstrom konsumieren, während Anthropic die Schleife ausführt und berichtet. Eine eigenständige Lektion zeigt, wie man mit der API über Claude Code selbst entwickelt — auch deshalb zählt der Rest des Kurses: Sie müssen wissen, wie guter Code aussieht, um zu prüfen, was ein Agent für Sie schreibt. Jede Lektion endet mit einer lauffähigen Demo, sodass Sie jede mit funktionierendem Code abschließen."
   },
   "faq": {
     "Data and Privacy": "Daten und Datenschutz",
@@ -1130,6 +1137,29 @@
     "Resource library for instructors": "Ressourcenbibliothek für Lehrpersonen",
     "Peer learning strategies": "Strategien für das Lernen unter Gleichaltrigen"
   },
+  "claudePlatform": {
+    "What is the Claude Developer Platform?": "Was ist die Claude Developer Platform?",
+    "Your first API call": "Ihr erster API-Aufruf",
+    "Choosing the right model": "Das richtige Modell wählen",
+    "The agent loop explained": "Die Agenten-Schleife erklärt",
+    "What is tool use?": "Was ist Tool-Nutzung?",
+    "What is thinking?": "Was ist Thinking?",
+    "Built-in tools": "Integrierte Werkzeuge",
+    "Skills": "Fähigkeiten",
+    "MCP": "MCP",
+    "Context management": "Kontext-Verwaltung",
+    "What are managed agents?": "Was sind Managed Agents?",
+    "Building your first managed agent": "Ihren ersten Managed Agent erstellen",
+    "Building with Claude Code": "Mit Claude Code entwickeln",
+    "Claude Platform 101 Quiz": "Claude Platform 101 Quiz",
+    "Teaching your Agent": "Ihrem Agenten beibringen",
+    "Extending your Agent": "Ihren Agenten erweitern",
+    "Managed Agents": "Managed Agents",
+    "Data and Privacy": "Daten und Datenschutz",
+    "Who this is for": "Für wen dieser Kurs ist",
+    "Recommended prerequisites": "Empfohlene Vorkenntnisse",
+    "Course sections": "Kursabschnitte"
+  },
   "_protected": {
     "Claude Code": [
       "Claude-Code"
diff --git a/src/data/es.json b/src/data/es.json
index 224bd48..acad211 100644
--- a/src/data/es.json
+++ b/src/data/es.json
@@ -100,7 +100,14 @@
     "Introduction to subagents": "Introducción a subagents",
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Aprende a usar y crear sub-agentes en Claude Code para gestionar el contexto, delegar tareas y construir flujos de trabajo especializados que mantengan tu conversación principal limpia y enfocada.",
     "AI Capabilities and Limitations": "Capacidades y limitaciones de AI",
-    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Comprende cómo se comportan los sistemas modernos de AI generativa, identifica tipos de resultados inesperados e implementa correcciones específicas."
+    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Comprende cómo se comportan los sistemas modernos de AI generativa, identifica tipos de resultados inesperados e implementa correcciones específicas.",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "Este curso enseña a los desarrolladores a construir sobre la Claude Developer Platform desde cero, tanto si has hecho algunas llamadas a la API como si solo has usado Claude a través de una ventana de chat.",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "Hay una gran brecha entre chatear con Claude en una pestaña del navegador y construir Claude dentro de algo que vas a lanzar. Un chat responde una pregunta y el hilo termina ahí. Una aplicación envía a Claude solicitudes estructuradas, le entrega herramientas, le permite actuar sobre sistemas reales y ejecuta ese bucle para un usuario o para un millón. La Claude Developer Platform existe para cerrar esa brecha, y es una habilidad distinta del prompting. Sacarle valor significa entender qué contiene una solicitud, cómo decide un agente qué hacer y dónde están los costos y los límites.",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "Este curso enseña a los desarrolladores a construir sobre la Claude Developer Platform desde cero, tanto si has hecho algunas llamadas a la API como si solo has usado Claude a través de una ventana de chat. Empezamos desde los primeros principios: qué contiene una solicitud a la API, qué es un bucle de agente, cómo la ventana de contexto delimita lo que Claude puede ver y cómo las herramientas y los permisos deciden lo que puede hacer. Así, las técnicas posteriores del curso se asientan como comprensión y no como una lista de llamadas para copiar.",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "Enviarás tu primera solicitud y leerás la respuesta; luego elegirás el modelo adecuado para cada tarea (Opus, Sonnet o Haiku) y sopesarás el equilibrio entre costo y latencia con tus propios ejemplos en lugar de adivinar. Después construirás el bucle del agente a mano para ver cómo Claude actúa, observa y decide, y luego lo reemplazarás con el Tool Runner del SDK una vez que entiendas lo que hace por ti. Le darás alcance a Claude mediante el uso de herramientas, le permitirás razonar problemas difíciles con el pensamiento extendido y mantendrás el gasto predecible con espacios de trabajo, límites y el Console Workbench.",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "La parte central del curso extiende el agente más allá de tu propio código: las herramientas integradas de Anthropic (búsqueda web, ejecución de código, obtención de páginas web) que corren en la infraestructura de Anthropic, las Habilidades que empaquetan un procedimiento una vez y lo reutilizan entre llamadas, los servidores MCP que conectan Claude con herramientas de terceros sin escribir un esquema, y los patrones de gestión del contexto que mantienen a un agente de larga ejecución dentro de la ventana y asequible más allá del turno diez.",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "La sección final delega el trabajo. Aprenderás cuándo ejecutar tu propio bucle y cuándo dejar que Anthropic ejecute por ti un agente gestionado y aislado en sandbox, y luego construirás uno de principio a fin, consumiendo el flujo de eventos mientras Anthropic ejecuta el bucle e informa. Una lección independiente muestra cómo construir con la API usando el propio Claude Code, que es también la razón por la que importa el resto del curso: necesitas saber cómo luce el buen código para revisar lo que un agente escribe por ti. Cada lección termina con una demo ejecutable, así que terminas cada una con código que funciona."
   },
   "faq": {
     "Data and Privacy": "Datos y Privacidad",
@@ -1130,6 +1137,29 @@
     "Resource library for instructors": "Biblioteca de recursos para instructores",
     "Peer learning strategies": "Estrategias de aprendizaje entre pares"
   },
+  "claudePlatform": {
+    "What is the Claude Developer Platform?": "¿Qué es la Claude Developer Platform?",
+    "Your first API call": "Tu primera llamada a la API",
+    "Choosing the right model": "Eligiendo el modelo adecuado",
+    "The agent loop explained": "El bucle del agente explicado",
+    "What is tool use?": "¿Qué es el uso de herramientas?",
+    "What is thinking?": "¿Qué es el pensamiento?",
+    "Built-in tools": "Herramientas integradas",
+    "Skills": "Habilidades",
+    "MCP": "MCP",
+    "Context management": "Gestión del contexto",
+    "What are managed agents?": "¿Qué son los Managed Agents?",
+    "Building your first managed agent": "Construyendo tu primer Managed Agent",
+    "Building with Claude Code": "Construyendo con Claude Code",
+    "Claude Platform 101 Quiz": "Cuestionario de Claude Platform 101",
+    "Teaching your Agent": "Enseñando a tu agente",
+    "Extending your Agent": "Extendiendo tu agente",
+    "Managed Agents": "Managed Agents",
+    "Data and Privacy": "Datos y privacidad",
+    "Who this is for": "A quién está dirigido",
+    "Recommended prerequisites": "Requisitos previos recomendados",
+    "Course sections": "Secciones del curso"
+  },
   "_protected": {
     "Claude Code": [
       "Código Claude"
diff --git a/src/data/fr.json b/src/data/fr.json
index 4afacb5..5cdc61c 100644
--- a/src/data/fr.json
+++ b/src/data/fr.json
@@ -100,7 +100,14 @@
     "Introduction to subagents": "Introduction aux subagents",
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Apprenez à utiliser et créer des sub-agents dans Claude Code pour gérer le contexte, déléguer des tâches et construire des flux de travail spécialisés qui maintiennent votre conversation principale propre et ciblée.",
     "AI Capabilities and Limitations": "Capacités et limites de l'AI",
-    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Comprenez le comportement des systèmes d'AI générative modernes, identifiez les types de résultats inattendus et mettez en œuvre des correctifs ciblés."
+    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Comprenez le comportement des systèmes d'AI générative modernes, identifiez les types de résultats inattendus et mettez en œuvre des correctifs ciblés.",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "Ce cours apprend aux développeurs à construire sur la Claude Developer Platform depuis la base, que vous ayez déjà fait quelques appels API ou que vous n'ayez utilisé Claude que dans une fenêtre de chat.",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "Il y a un grand écart entre discuter avec Claude dans un onglet de navigateur et intégrer Claude dans un produit que vous livrez. Un chat répond à une question et le fil s'arrête là. Une application envoie à Claude des requêtes structurées, lui confie des outils, le laisse agir sur de vrais systèmes et fait tourner cette boucle pour un utilisateur ou un million. La Claude Developer Platform existe pour combler cet écart, et c'est une compétence différente du prompting. En tirer de la valeur suppose de comprendre ce que contient une requête, comment un agent décide quoi faire, et où se situent les coûts et les limites.",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "Ce cours apprend aux développeurs à construire sur la Claude Developer Platform depuis la base, que vous ayez déjà fait quelques appels API ou que vous n'ayez utilisé Claude que dans une fenêtre de chat. Nous partons des premiers principes : ce que contient une requête API, ce qu'est une boucle d'agent, comment la fenêtre de contexte borne ce que Claude peut voir, et comment les outils et les permissions décident de ce qu'il peut faire. Les techniques abordées ensuite s'ancrent alors comme de la compréhension, et non comme une liste d'appels à recopier.",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "Vous enverrez votre première requête et lirez la réponse, puis choisirez le bon modèle pour la tâche (Opus, Sonnet ou Haiku) et évaluerez le compromis coût-latence sur vos propres exemples plutôt qu'au jugé. Vous construirez ensuite la boucle d'agent à la main pour voir comment Claude agit, observe et décide, puis vous remplacerez cette boucle artisanale par le Tool Runner du SDK une fois compris ce qu'il fait pour vous. Vous donnerez de la portée à Claude grâce à l'utilisation d'outils, le laisserez raisonner sur des problèmes difficiles avec la réflexion étendue, et garderez les dépenses prévisibles avec les espaces de travail, les limites et le Console Workbench.",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "Le milieu du cours étend l'agent au-delà de votre propre code : les outils intégrés d'Anthropic (recherche web, exécution de code, récupération de pages web) qui tournent sur l'infrastructure d'Anthropic, les Compétences qui empaquettent une procédure une fois pour la réutiliser d'un appel à l'autre, les serveurs MCP qui connectent Claude à des outils tiers sans écrire de schéma, et les schémas de gestion du contexte qui gardent un agent de longue durée dans la fenêtre et abordable au-delà du dixième tour.",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "La dernière section délègue le travail. Vous apprendrez quand faire tourner votre propre boucle et quand laisser Anthropic exécuter pour vous un agent géré dans un bac à sable, puis vous en construirez un de bout en bout, en consommant le flux d'événements pendant qu'Anthropic exécute la boucle et rend compte. Une leçon autonome montre comment construire avec l'API en utilisant Claude Code lui-même — c'est aussi pourquoi le reste du cours compte : il faut savoir à quoi ressemble du bon code pour relire ce qu'un agent écrit à votre place. Chaque leçon se termine par une démo exécutable, vous finissez donc chacune avec du code qui fonctionne."
   },
   "faq": {
     "Data and Privacy": "Données et Confidentialité",
@@ -1130,6 +1137,29 @@
     "Resource library for instructors": "Bibliothèque de ressources pour les instructeurs",
     "Peer learning strategies": "Stratégies d'apprentissage entre pairs"
   },
+  "claudePlatform": {
+    "What is the Claude Developer Platform?": "Qu'est-ce que la Claude Developer Platform ?",
+    "Your first API call": "Votre premier appel API",
+    "Choosing the right model": "Choisir le bon modèle",
+    "The agent loop explained": "La boucle d'agent expliquée",
+    "What is tool use?": "Qu'est-ce que l'utilisation d'outils ?",
+    "What is thinking?": "Qu'est-ce que la réflexion ?",
+    "Built-in tools": "Outils intégrés",
+    "Skills": "Compétences",
+    "MCP": "MCP",
+    "Context management": "Gestion du contexte",
+    "What are managed agents?": "Que sont les Managed Agents ?",
+    "Building your first managed agent": "Construire votre premier Managed Agent",
+    "Building with Claude Code": "Construire avec Claude Code",
+    "Claude Platform 101 Quiz": "Quiz Claude Platform 101",
+    "Teaching your Agent": "Enseigner à votre agent",
+    "Extending your Agent": "Étendre votre agent",
+    "Managed Agents": "Managed Agents",
+    "Data and Privacy": "Données et confidentialité",
+    "Who this is for": "À qui ce cours s’adresse",
+    "Recommended prerequisites": "Prérequis recommandés",
+    "Course sections": "Sections du cours"
+  },
   "_protected": {
     "Claude Code": [
       "Code Claude"
diff --git a/src/data/it.json b/src/data/it.json
index e23b5d8..19dc25c 100644
--- a/src/data/it.json
+++ b/src/data/it.json
@@ -101,7 +101,14 @@
     "Introduction to subagents": "Introduzione ai subagenti",
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Scopri come utilizzare e creare agenti secondari in Claude Code per gestire il contesto, delegare attività e creare flussi di lavoro specializzati che mantengono la conversazione principale pulita e mirata.",
     "AI Capabilities and Limitations": "Funzionalità e limitazioni dell'IA",
-    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Comprendi come si comportano i moderni sistemi di intelligenza artificiale generativa, identifica i tipi di output imprevisti e implementa soluzioni mirate."
+    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Comprendi come si comportano i moderni sistemi di intelligenza artificiale generativa, identifica i tipi di output imprevisti e implementa soluzioni mirate.",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "Questo corso insegna agli sviluppatori a costruire sulla Claude Developer Platform partendo dalle basi, sia che tu abbia già fatto qualche chiamata API sia che tu abbia usato Claude solo in una finestra di chat.",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "C'è un grande divario tra chattare con Claude in una scheda del browser e integrare Claude in qualcosa che metterai in produzione. Una chat risponde a una domanda e il filo si chiude lì. Un'applicazione invia a Claude richieste strutturate, gli affida strumenti, gli permette di agire su sistemi reali ed esegue quel loop per un utente o per un milione. La Claude Developer Platform esiste per colmare quel divario, ed è una competenza diversa dal prompting. Trarne valore significa capire cosa contiene una richiesta, come un agente decide cosa fare e dove si trovano i costi e i limiti.",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "Questo corso insegna agli sviluppatori a costruire sulla Claude Developer Platform partendo dalle basi, sia che tu abbia già fatto qualche chiamata API sia che tu abbia usato Claude solo in una finestra di chat. Partiamo dai principi primi: cosa contiene una richiesta API, cos'è un loop dell'agente, come la finestra di contesto delimita ciò che Claude può vedere e come strumenti e permessi decidono ciò che può fare. Così le tecniche della parte successiva del corso si fissano come comprensione, non come un elenco di chiamate da copiare.",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "Invierai la tua prima richiesta e leggerai la risposta, poi sceglierai il modello giusto per il compito (Opus, Sonnet o Haiku) e valuterai il compromesso costo-latenza sui tuoi esempi invece di tirare a indovinare. Da lì costruirai il loop dell'agente a mano per vedere come Claude agisce, osserva e decide, poi sostituirai quel loop artigianale con il Tool Runner dell'SDK una volta capito cosa fa per te. Darai a Claude maggiore portata con l'uso degli strumenti, lo lascerai ragionare su problemi difficili con il ragionamento esteso e manterrai la spesa prevedibile con workspace, limiti e il Console Workbench.",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "La parte centrale del corso estende l'agente oltre il tuo codice: gli strumenti integrati di Anthropic (ricerca web, esecuzione di codice, recupero di pagine web) che girano sull'infrastruttura di Anthropic, le Skills che impacchettano una procedura una volta sola per riutilizzarla tra le chiamate, i server MCP che collegano Claude a strumenti di terze parti senza scrivere uno schema, e i pattern di gestione del contesto che tengono un agente a lunga esecuzione dentro la finestra e sostenibile oltre il decimo turno.",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "La sezione finale delega il lavoro. Imparerai quando eseguire il tuo loop e quando lasciare che Anthropic esegua per te un agente gestito e in sandbox, poi ne costruirai uno end-to-end, consumando il flusso di eventi mentre Anthropic esegue il loop e riferisce. Una lezione a sé mostra come costruire con l'API usando Claude Code stesso — ed è anche il motivo per cui conta il resto del corso: per rivedere il codice che un agente scrive al posto tuo devi sapere che aspetto ha il buon codice. Ogni lezione termina con una demo eseguibile, così concludi ciascuna con codice funzionante."
   },
   "faq": {
     "Data and Privacy": "Dati e Privacy",
@@ -1131,6 +1138,29 @@
     "Resource library for instructors": "Libreria di risorse per gli istruttori",
     "Peer learning strategies": "Strategie di apprendimento tra pari"
   },
+  "claudePlatform": {
+    "What is the Claude Developer Platform?": "Cos'è la Claude Developer Platform?",
+    "Your first API call": "La tua prima chiamata API",
+    "Choosing the right model": "Scegliere il modello giusto",
+    "The agent loop explained": "Il loop dell’agente spiegato",
+    "What is tool use?": "Cos'è l'uso degli strumenti?",
+    "What is thinking?": "Cos'è il ragionamento (thinking)?",
+    "Built-in tools": "Strumenti integrati",
+    "Skills": "Skills",
+    "MCP": "MCP",
+    "Context management": "Gestione del contesto",
+    "What are managed agents?": "Cosa sono i Managed Agents?",
+    "Building your first managed agent": "Costruire il tuo primo Managed Agent",
+    "Building with Claude Code": "Costruire con Claude Code",
+    "Claude Platform 101 Quiz": "Quiz di Claude Platform 101",
+    "Teaching your Agent": "Insegnare al tuo agente",
+    "Extending your Agent": "Estendere il tuo agente",
+    "Managed Agents": "Managed Agents",
+    "Data and Privacy": "Dati e privacy",
+    "Who this is for": "A chi è rivolto",
+    "Recommended prerequisites": "Prerequisiti consigliati",
+    "Course sections": "Sezioni del corso"
+  },
   "_protected": {
     "Claude Code": [
       "Codice Claudio"
diff --git a/src/data/ja.json b/src/data/ja.json
index d311a6f..38a6b0a 100644
--- a/src/data/ja.json
+++ b/src/data/ja.json
@@ -100,7 +100,14 @@
     "Introduction to subagents": "subagents入門",
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Claude Codeでsub-agentを使用・作成して、コンテキストを管理し、タスクを委任し、メインの会話をクリーンで集中した状態に保つ専門的なワークフローを構築する方法を学びます。",
     "AI Capabilities and Limitations": "AIの能力と限界",
-    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "現代の生成AIシステムの動作を理解し、予期しない出力の種類を特定し、的を絞った修正を実装します。"
+    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "現代の生成AIシステムの動作を理解し、予期しない出力の種類を特定し、的を絞った修正を実装します。",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "このコースは、APIを数回呼び出したことがある方でも、チャット画面でしかClaudeを使ったことがない方でも、Claude Developer Platform上で開発する方法を基礎から教えます。",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "ブラウザのタブでClaudeとチャットすることと、Claudeを実際に出荷する製品に組み込むことの間には大きな隔たりがあります。チャットは質問に答えればそこで終わりますが、アプリケーションはClaudeに構造化されたリクエストを送り、ツールを持たせ、実際のシステムで動作させ、そのループを1人のユーザーにも100万人にも回します。Claude Developer Platformはその隔たりを埋めるために存在し、プロンプト作成とは別のスキルです。プラットフォームから価値を引き出すには、リクエストに何が含まれるか、エージェントが何をするかをどう決めるか、コストと制限がどこにあるかを理解する必要があります。",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "このコースは、APIを数回呼び出したことがある方でも、チャット画面でしかClaudeを使ったことがない方でも、Claude Developer Platform上で開発する方法を基礎から教えます。APIリクエストに何が含まれるか、エージェントループとは何か、コンテキストウィンドウがClaudeの見える範囲をどう制限するか、ツールと権限がClaudeにできることをどう決めるか — 第一原理から始めます。そうすることで、コース後半のテクニックがコピーする呼び出しのリストではなく、理解として身につきます。",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "最初のリクエストを送ってレスポンスを読み、次に仕事に合ったモデル（Opus、Sonnet、Haiku）を選び、コストとレイテンシのトレードオフを推測ではなく自分の例で見極めます。その後、エージェントループを手作りしてClaudeがどう行動し、観察し、決定するかを確かめ、その手書きループが何を肩代わりしてくれるかを理解した上でSDKのTool Runnerに置き換えます。ツール使用でClaudeの届く範囲を広げ、拡張思考で難しい問題を推論させ、ワークスペース・上限・Console Workbenchで支出を予測可能に保ちます。",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "コース中盤では、エージェントを自分のコードの外へ拡張します。Anthropicのインフラ上で実行される組み込みツール（ウェブ検索、コード実行、ウェブ取得）、手順を一度パッケージ化して呼び出しをまたいで再利用するスキル、スキーマを書かずにClaudeをサードパーティのツールにつなぐMCPサーバー、そして長時間動くエージェントをウィンドウ内に収め、10ターンを超えてもコストを抑えるコンテキスト管理パターンを扱います。",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "最後のセクションでは仕事を委ねます。いつ自分のループを回し、いつAnthropicにサンドボックス化されたManaged Agentを任せるかを学び、Anthropicがループを実行して報告するイベントストリームを消費しながら、1つをエンドツーエンドで構築します。独立したレッスンでは、Claude Code自体を使ってAPIで構築する方法を示します。これはコースの残りが重要である理由でもあります。エージェントが代わりに書いたコードをレビューするには、良いコードがどんな姿かを知っている必要があるからです。すべてのレッスンは実行可能なデモで終わるため、各レッスンを動くコードとともに終えられます。"
   },
   "faq": {
     "Data and Privacy": "データとプライバシー",
@@ -1130,6 +1137,29 @@
     "Resource library for instructors": "インストラクター向けリソースライブラリ",
     "Peer learning strategies": "ピアラーニング戦略"
   },
+  "claudePlatform": {
+    "What is the Claude Developer Platform?": "Claude Developer Platformとは何ですか?",
+    "Your first API call": "初めてのAPI呼び出し",
+    "Choosing the right model": "適切なモデルの選択",
+    "The agent loop explained": "エージェントループの解説",
+    "What is tool use?": "ツール使用とは何ですか?",
+    "What is thinking?": "思考機能とは何ですか?",
+    "Built-in tools": "組み込みツール",
+    "Skills": "スキル",
+    "MCP": "MCP",
+    "Context management": "コンテキスト管理",
+    "What are managed agents?": "Managed Agentsとは何ですか?",
+    "Building your first managed agent": "初めてのManaged Agentの構築",
+    "Building with Claude Code": "Claude Codeで構築する",
+    "Claude Platform 101 Quiz": "Claude Platform 101クイズ",
+    "Teaching your Agent": "エージェントに教える",
+    "Extending your Agent": "エージェントを拡張する",
+    "Managed Agents": "Managed Agents",
+    "Data and Privacy": "データとプライバシー",
+    "Who this is for": "対象者",
+    "Recommended prerequisites": "推奨される前提知識",
+    "Course sections": "コースセクション"
+  },
   "_protected": {
     "Claude Code": ["クロードコード"],
     "Claude": ["クロード"],
diff --git a/src/data/ko.json b/src/data/ko.json
index 30e861c..5fd7b91 100644
--- a/src/data/ko.json
+++ b/src/data/ko.json
@@ -100,7 +100,14 @@
     "Introduction to subagents": "subagents 소개",
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Claude Code에서 sub-agent를 사용하고 생성하여 컨텍스트를 관리하고, 작업을 위임하고, 메인 대화를 깔끔하게 유지하는 전문화된 워크플로를 구축하는 방법을 학습합니다.",
     "AI Capabilities and Limitations": "AI의 역량과 한계",
-    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "현대 생성형 AI 시스템의 동작 방식을 이해하고, 예기치 않은 출력 유형을 식별하며, 표적화된 해결책을 적용합니다."
+    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "현대 생성형 AI 시스템의 동작 방식을 이해하고, 예기치 않은 출력 유형을 식별하며, 표적화된 해결책을 적용합니다.",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "이 과정은 API 호출을 몇 번 해본 분이든 채팅 창으로만 Claude를 사용해 본 분이든, Claude Developer Platform 위에서 개발하는 방법을 기초부터 가르칩니다.",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "브라우저 탭에서 Claude와 대화하는 것과 Claude를 실제로 출시할 제품에 통합하는 것 사이에는 큰 간극이 있습니다. 채팅은 질문에 답하면 거기서 끝나지만, 애플리케이션은 Claude에 구조화된 요청을 보내고, 도구를 쥐여 주고, 실제 시스템에서 동작하게 하며, 그 루프를 한 명의 사용자든 백만 명이든 돌립니다. Claude Developer Platform은 그 간극을 메우기 위해 존재하며, 이는 프롬프트 작성과는 다른 기술입니다. 플랫폼에서 가치를 끌어내려면 요청에 무엇이 담기는지, 에이전트가 무엇을 할지 어떻게 결정하는지, 비용과 한도가 어디에 있는지 이해해야 합니다.",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "이 과정은 API 호출을 몇 번 해본 분이든 채팅 창으로만 Claude를 사용해 본 분이든, Claude Developer Platform 위에서 개발하는 방법을 기초부터 가르칩니다. API 요청에 무엇이 담기는지, 에이전트 루프란 무엇인지, 컨텍스트 윈도우가 Claude가 볼 수 있는 범위를 어떻게 한정하는지, 도구와 권한이 Claude가 할 수 있는 일을 어떻게 결정하는지 — 첫 원리부터 시작합니다. 그래야 과정 후반의 기법들이 베껴 쓸 호출 목록이 아니라 이해로 자리 잡습니다.",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "첫 요청을 보내고 응답을 읽는 것에서 시작해, 작업에 알맞은 모델(Opus, Sonnet, Haiku)을 고르고 비용·지연 트레이드오프를 추측이 아니라 직접 만든 예제로 가늠해 봅니다. 이어서 에이전트 루프를 손수 만들어 Claude가 어떻게 행동하고 관찰하고 결정하는지 본 뒤, 그 수제 루프가 무엇을 대신해 주는지 이해한 상태에서 SDK의 Tool Runner로 대체합니다. 도구 사용으로 Claude의 손이 닿는 범위를 넓히고, 확장 사고로 어려운 문제를 추론하게 하며, 워크스페이스·한도·Console Workbench로 지출을 예측 가능하게 유지합니다.",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "과정 중반에는 에이전트를 내 코드 바깥으로 확장합니다. Anthropic 인프라에서 실행되는 내장 도구(웹 검색, 코드 실행, 웹 가져오기), 절차를 한 번 패키징해 호출마다 재사용하는 Skill, 스키마를 작성하지 않고 Claude를 서드파티 도구에 연결하는 MCP 서버, 그리고 장시간 실행되는 에이전트를 윈도우 안에 머물게 하고 10턴이 지나도 비용을 감당 가능하게 하는 컨텍스트 관리 패턴을 다룹니다.",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "마지막 섹션에서는 일을 맡기는 법을 다룹니다. 언제 내 루프를 직접 돌리고 언제 Anthropic이 샌드박스화된 Managed Agent를 대신 돌리게 할지 배우고, Anthropic이 루프를 실행하며 보고하는 이벤트 스트림을 소비하면서 하나를 끝까지 만들어 봅니다. 별도 레슨에서는 Claude Code 자체로 API 기반 개발을 하는 법을 보여 주는데, 이것이 과정 전체가 중요한 이유이기도 합니다: 에이전트가 대신 써 주는 코드를 검토하려면 좋은 코드가 어떤 모습인지 알아야 하기 때문입니다. 모든 레슨은 실행 가능한 데모로 끝나므로, 각 레슨을 동작하는 코드와 함께 마치게 됩니다."
   },
   "faq": {
     "Data and Privacy": "데이터 및 개인 정보 보호",
@@ -1130,6 +1137,29 @@
     "Resource library for instructors": "강사용 자료 라이브러리",
     "Peer learning strategies": "동료 학습 전략"
   },
+  "claudePlatform": {
+    "What is the Claude Developer Platform?": "Claude Developer Platform이란 무엇인가요?",
+    "Your first API call": "첫 번째 API 호출",
+    "Choosing the right model": "알맞은 모델 선택하기",
+    "The agent loop explained": "에이전트 루프 이해하기",
+    "What is tool use?": "도구 사용이란 무엇인가요?",
+    "What is thinking?": "사고 기능이란 무엇인가요?",
+    "Built-in tools": "내장 도구",
+    "Skills": "Skill",
+    "MCP": "MCP",
+    "Context management": "컨텍스트 관리",
+    "What are managed agents?": "Managed Agents란 무엇인가요?",
+    "Building your first managed agent": "첫 번째 Managed Agent 만들기",
+    "Building with Claude Code": "Claude Code로 빌드하기",
+    "Claude Platform 101 Quiz": "Claude Platform 101 퀴즈",
+    "Teaching your Agent": "에이전트 가르치기",
+    "Extending your Agent": "에이전트 확장하기",
+    "Managed Agents": "Managed Agents",
+    "Data and Privacy": "데이터 및 개인정보",
+    "Who this is for": "추천 대상",
+    "Recommended prerequisites": "권장 선수 지식",
+    "Course sections": "과정 구성"
+  },
   "_protected": {
     "Claude Code": ["클로드 코드", "클로드 Code", "클로우드 코드"],
     "Claude": ["클로드", "클로우드"],
diff --git a/src/data/pt-BR.json b/src/data/pt-BR.json
index 7c8d567..ac5df4b 100644
--- a/src/data/pt-BR.json
+++ b/src/data/pt-BR.json
@@ -100,7 +100,14 @@
     "Introduction to subagents": "Introdução a subagents",
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Aprenda a usar e criar sub-agentes no Claude Code para gerenciar contexto, delegar tarefas e construir fluxos de trabalho especializados que mantêm sua conversa principal limpa e focada.",
     "AI Capabilities and Limitations": "Capacidades e limitações de AI",
-    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Entenda como os sistemas modernos de AI generativa se comportam, identifique tipos de resultados inesperados e implemente correções específicas."
+    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Entenda como os sistemas modernos de AI generativa se comportam, identifique tipos de resultados inesperados e implemente correções específicas.",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "Este curso ensina desenvolvedores a construir sobre a Claude Developer Platform desde o início, quer você já tenha feito algumas chamadas de API ou só tenha usado o Claude por uma janela de chat.",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "Há uma grande distância entre conversar com o Claude em uma aba do navegador e construir o Claude dentro de algo que você vai lançar. Um chat responde a uma pergunta e a conversa termina ali. Uma aplicação envia ao Claude solicitações estruturadas, entrega ferramentas a ele, permite que atue em sistemas reais e executa esse loop para um usuário ou um milhão. A Claude Developer Platform existe para fechar essa lacuna, e isso é uma habilidade diferente de prompting. Extrair valor dela significa entender o que há em uma solicitação, como um agente decide o que fazer e onde estão os custos e os limites.",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "Este curso ensina desenvolvedores a construir sobre a Claude Developer Platform desde o início, quer você já tenha feito algumas chamadas de API ou só tenha usado o Claude por uma janela de chat. Começamos pelos primeiros princípios: o que uma solicitação de API contém, o que é um loop de agente, como a janela de contexto delimita o que o Claude pode ver e como ferramentas e permissões decidem o que ele pode fazer. Assim, as técnicas da parte final do curso se firmam como compreensão, e não como uma lista de chamadas para copiar.",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "Você enviará sua primeira solicitação e lerá a resposta; depois escolherá o modelo certo para a tarefa (Opus, Sonnet ou Haiku) e pesará o equilíbrio entre custo e latência nos seus próprios exemplos, em vez de adivinhar. Em seguida, construirá o loop do agente à mão para ver como o Claude age, observa e decide, e então substituirá esse loop manual pelo Tool Runner do SDK quando entender o que ele faz por você. Você dará alcance ao Claude por meio do uso de ferramentas, deixará que ele raciocine sobre problemas difíceis com o pensamento estendido e manterá os gastos previsíveis com workspaces, limites e o Console Workbench.",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "A parte central do curso estende o agente para além do seu próprio código: as ferramentas integradas da Anthropic (busca na web, execução de código, captura de páginas) que rodam na infraestrutura da Anthropic, as Habilidades que empacotam um procedimento uma vez e o reutilizam entre chamadas, os servidores MCP que conectam o Claude a ferramentas de terceiros sem escrever um schema, e os padrões de gerenciamento de contexto que mantêm um agente de longa duração dentro da janela e acessível depois do décimo turno.",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "A seção final delega o trabalho. Você aprenderá quando executar seu próprio loop e quando deixar a Anthropic executar por você um agente gerenciado em sandbox, e então construirá um de ponta a ponta, consumindo o fluxo de eventos enquanto a Anthropic executa o loop e reporta. Uma lição independente mostra como construir com a API usando o próprio Claude Code — que é também o motivo pelo qual o resto do curso importa: você precisa saber como é um bom código para revisar o que um agente escreve por você. Cada lição termina com uma demonstração executável, então você conclui cada uma com código funcionando."
   },
   "faq": {
     "Data and Privacy": "Dados e Privacidade",
@@ -1130,6 +1137,29 @@
     "Resource library for instructors": "Biblioteca de recursos para instrutores",
     "Peer learning strategies": "Estratégias de aprendizagem entre pares"
   },
+  "claudePlatform": {
+    "What is the Claude Developer Platform?": "O que é a Claude Developer Platform?",
+    "Your first API call": "Sua primeira chamada de API",
+    "Choosing the right model": "Escolhendo o modelo certo",
+    "The agent loop explained": "O loop do agente explicado",
+    "What is tool use?": "O que é uso de ferramentas?",
+    "What is thinking?": "O que é o pensamento (thinking)?",
+    "Built-in tools": "Ferramentas integradas",
+    "Skills": "Habilidades",
+    "MCP": "MCP",
+    "Context management": "Gerenciamento de contexto",
+    "What are managed agents?": "O que são Managed Agents?",
+    "Building your first managed agent": "Construindo seu primeiro Managed Agent",
+    "Building with Claude Code": "Construindo com Claude Code",
+    "Claude Platform 101 Quiz": "Questionário de Claude Platform 101",
+    "Teaching your Agent": "Ensinando seu agente",
+    "Extending your Agent": "Estendendo seu agente",
+    "Managed Agents": "Managed Agents",
+    "Data and Privacy": "Dados e privacidade",
+    "Who this is for": "Para quem é este curso",
+    "Recommended prerequisites": "Pré-requisitos recomendados",
+    "Course sections": "Seções do curso"
+  },
   "_protected": {
     "Claude Code": [
       "Código Claude"
diff --git a/src/data/ru.json b/src/data/ru.json
index 5a19f27..952713d 100644
--- a/src/data/ru.json
+++ b/src/data/ru.json
@@ -100,7 +100,14 @@
     "Introduction to subagents": "Введение в субагентов",
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Узнайте, как использовать и создавать субагентов в Claude Code для управления контекстом, делегирования задач и построения специализированных рабочих процессов, которые поддерживают чистоту и фокус основного диалога.",
     "AI Capabilities and Limitations": "Возможности и ограничения ИИ",
-    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Разберитесь в поведении современных генеративных систем ИИ, определите типы неожиданных результатов и внедрите целевые исправления."
+    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Разберитесь в поведении современных генеративных систем ИИ, определите типы неожиданных результатов и внедрите целевые исправления.",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "Этот курс учит разработчиков создавать решения на Claude Developer Platform с нуля — независимо от того, делали ли вы уже несколько вызовов API или пользовались Claude только через окно чата.",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "Между общением с Claude во вкладке браузера и встраиванием Claude в продукт, который вы выпускаете, лежит большая дистанция. Чат отвечает на вопрос — и на этом всё заканчивается. Приложение же отправляет Claude структурированные запросы, даёт ему инструменты, позволяет действовать в реальных системах и запускает этот цикл для одного пользователя или миллиона. Claude Developer Platform существует, чтобы закрыть этот разрыв, и это другой навык, нежели промптинг. Чтобы извлечь из платформы пользу, нужно понимать, что входит в запрос, как агент решает, что делать, и где находятся затраты и ограничения.",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "Этот курс учит разработчиков создавать решения на Claude Developer Platform с нуля — независимо от того, делали ли вы уже несколько вызовов API или пользовались Claude только через окно чата. Мы начинаем с первых принципов: что содержит запрос к API, что такое цикл агента, как контекстное окно ограничивает то, что видит Claude, и как инструменты и разрешения определяют, что он может делать. Тогда приёмы из дальнейшей части курса усваиваются как понимание, а не как список вызовов для копирования.",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "Вы отправите свой первый запрос и прочитаете ответ, затем подберёте подходящую модель для задачи (Opus, Sonnet или Haiku) и оцените компромисс между стоимостью и задержкой на собственных примерах, а не наугад. Далее вы соберёте цикл агента вручную, чтобы увидеть, как Claude действует, наблюдает и принимает решения, а затем замените этот самодельный цикл на Tool Runner из SDK — уже понимая, что он делает за вас. Вы расширите возможности Claude через использование инструментов, позволите ему продумывать сложные задачи в режиме расширенного размышления и сохраните расходы предсказуемыми с помощью рабочих пространств, лимитов и Console Workbench.",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "Середина курса выводит агента за пределы вашего собственного кода: встроенные инструменты Anthropic (веб-поиск, выполнение кода, загрузка веб-страниц), работающие на инфраструктуре Anthropic; навыки, которые упаковывают процедуру один раз и переиспользуют её между вызовами; серверы MCP, подключающие Claude к сторонним инструментам без написания схемы; и шаблоны управления контекстом, которые удерживают долгоживущего агента в пределах окна и делают его экономичным и после десятого хода.",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "Финальный раздел — о передаче работы. Вы узнаете, когда запускать собственный цикл, а когда позволить Anthropic запустить для вас изолированный управляемый агент, а затем соберёте такой агент целиком, потребляя поток событий, пока Anthropic выполняет цикл и отчитывается. Отдельный урок показывает, как разрабатывать с API с помощью самого Claude Code — в этом и причина важности остальной части курса: чтобы проверять код, который агент пишет за вас, нужно знать, как выглядит хороший код. Каждый урок заканчивается работающей демонстрацией, так что вы завершаете каждый с рабочим кодом."
   },
   "faq": {
     "Data and Privacy": "Данные и конфиденциальность",
@@ -1130,6 +1137,29 @@
     "Resource library for instructors": "Библиотека ресурсов для инструкторов",
     "Peer learning strategies": "Стратегии взаимного обучения"
   },
+  "claudePlatform": {
+    "What is the Claude Developer Platform?": "Что такое Claude Developer Platform?",
+    "Your first API call": "Ваш первый вызов API",
+    "Choosing the right model": "Выбор подходящей модели",
+    "The agent loop explained": "Как устроен цикл агента",
+    "What is tool use?": "Что такое использование инструментов?",
+    "What is thinking?": "Что такое режим размышления?",
+    "Built-in tools": "Встроенные инструменты",
+    "Skills": "Навыки",
+    "MCP": "MCP",
+    "Context management": "Управление контекстом",
+    "What are managed agents?": "Что такое Managed Agents?",
+    "Building your first managed agent": "Создание вашего первого Managed Agent",
+    "Building with Claude Code": "Разработка с Claude Code",
+    "Claude Platform 101 Quiz": "Тест по Claude Platform 101",
+    "Teaching your Agent": "Обучение вашего агента",
+    "Extending your Agent": "Расширение вашего агента",
+    "Managed Agents": "Managed Agents",
+    "Data and Privacy": "Данные и конфиденциальность",
+    "Who this is for": "Для кого этот курс",
+    "Recommended prerequisites": "Рекомендуемые предварительные знания",
+    "Course sections": "Разделы курса"
+  },
   "_protected": {
     "Claude Code": [
       "Клод Код"
diff --git a/src/data/vi.json b/src/data/vi.json
index 791957c..9c694fb 100644
--- a/src/data/vi.json
+++ b/src/data/vi.json
@@ -100,7 +100,14 @@
     "Introduction to subagents": "Giới thiệu về subagent",
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "Học cách sử dụng và tạo sub-agent trong Claude Code để quản lý ngữ cảnh, ủy thác tác vụ và xây dựng quy trình làm việc chuyên biệt giúp cuộc trò chuyện chính của bạn gọn gàng và tập trung.",
     "AI Capabilities and Limitations": "Năng lực và Hạn chế của AI",
-    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Hiểu cách các hệ thống AI tạo sinh hiện đại hoạt động, nhận diện các loại đầu ra không mong đợi và triển khai các bản sửa lỗi có mục tiêu."
+    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "Hiểu cách các hệ thống AI tạo sinh hiện đại hoạt động, nhận diện các loại đầu ra không mong đợi và triển khai các bản sửa lỗi có mục tiêu.",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "Khóa học này dạy các lập trình viên xây dựng trên Claude Developer Platform từ những điều cơ bản, dù bạn đã từng gọi API vài lần hay mới chỉ dùng Claude qua cửa sổ trò chuyện.",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "Có một khoảng cách lớn giữa việc trò chuyện với Claude trong một thẻ trình duyệt và việc đưa Claude vào một sản phẩm bạn sẽ phát hành. Một cuộc chat trả lời câu hỏi rồi dừng lại ở đó. Một ứng dụng gửi cho Claude các yêu cầu có cấu trúc, trao cho nó công cụ, để nó hành động trên các hệ thống thực, và chạy vòng lặp đó cho một người dùng hay một triệu người. Claude Developer Platform tồn tại để thu hẹp khoảng cách đó, và đây là một kỹ năng khác với việc viết prompt. Khai thác giá trị từ nền tảng đòi hỏi hiểu một yêu cầu chứa gì, tác tử quyết định việc cần làm ra sao, và chi phí cùng giới hạn nằm ở đâu.",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "Khóa học này dạy các lập trình viên xây dựng trên Claude Developer Platform từ những điều cơ bản, dù bạn đã từng gọi API vài lần hay mới chỉ dùng Claude qua cửa sổ trò chuyện. Chúng ta bắt đầu từ những nguyên lý nền tảng: một yêu cầu API chứa gì, vòng lặp tác tử là gì, cửa sổ ngữ cảnh giới hạn những gì Claude thấy được ra sao, và công cụ cùng quyền hạn quyết định nó được làm gì như thế nào. Nhờ vậy, các kỹ thuật ở phần sau của khóa học đọng lại thành sự thấu hiểu thay vì một danh sách lệnh gọi để sao chép.",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "Bạn sẽ gửi yêu cầu đầu tiên và đọc phản hồi, rồi chọn mô hình phù hợp cho công việc (Opus, Sonnet hoặc Haiku) và cân nhắc đánh đổi giữa chi phí và độ trễ trên chính ví dụ của mình thay vì đoán mò. Từ đó bạn sẽ tự tay xây dựng vòng lặp tác tử để thấy Claude hành động, quan sát và quyết định ra sao, rồi thay vòng lặp viết tay đó bằng Tool Runner của SDK khi đã hiểu nó làm gì cho bạn. Bạn sẽ mở rộng tầm với của Claude qua việc sử dụng công cụ, để nó suy luận các bài toán khó với chế độ suy nghĩ mở rộng, và giữ chi tiêu trong tầm dự đoán với workspace, hạn mức và Console Workbench.",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "Phần giữa của khóa học mở rộng tác tử ra ngoài mã của riêng bạn: các công cụ tích hợp sẵn của Anthropic (tìm kiếm web, thực thi mã, truy xuất web) chạy trên hạ tầng của Anthropic, Skills đóng gói một quy trình một lần để tái sử dụng qua các lần gọi, máy chủ MCP kết nối Claude với công cụ bên thứ ba mà không cần viết schema, và các mẫu quản lý ngữ cảnh giúp tác tử chạy dài hạn ở trong cửa sổ và vẫn kham nổi chi phí sau lượt thứ mười.",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "Phần cuối bàn về việc giao việc. Bạn sẽ học khi nào tự chạy vòng lặp của mình và khi nào để Anthropic chạy giúp bạn một managed agent trong sandbox, rồi xây dựng một cái từ đầu đến cuối, tiêu thụ luồng sự kiện trong khi Anthropic chạy vòng lặp và báo cáo lại. Một bài học độc lập chỉ cách xây dựng với API bằng chính Claude Code — đó cũng là lý do phần còn lại của khóa học quan trọng: bạn cần biết mã tốt trông như thế nào để rà soát những gì tác tử viết thay bạn. Mỗi bài học kết thúc bằng một bản demo chạy được, nên bạn hoàn thành mỗi bài với mã hoạt động thực sự."
   },
   "faq": {
     "Data and Privacy": "Dữ liệu và Quyền riêng tư",
@@ -1130,6 +1137,29 @@
     "Resource library for instructors": "Thư viện tài nguyên cho giảng viên",
     "Peer learning strategies": "Chiến lược học tập đồng đẳng"
   },
+  "claudePlatform": {
+    "What is the Claude Developer Platform?": "Claude Developer Platform là gì?",
+    "Your first API call": "Lệnh gọi API đầu tiên của bạn",
+    "Choosing the right model": "Chọn mô hình phù hợp",
+    "The agent loop explained": "Giải thích vòng lặp tác tử",
+    "What is tool use?": "Sử dụng công cụ là gì?",
+    "What is thinking?": "Chế độ suy nghĩ (thinking) là gì?",
+    "Built-in tools": "Công cụ tích hợp sẵn",
+    "Skills": "Skills",
+    "MCP": "MCP",
+    "Context management": "Quản lý ngữ cảnh",
+    "What are managed agents?": "Managed Agents là gì?",
+    "Building your first managed agent": "Xây dựng Managed Agent đầu tiên của bạn",
+    "Building with Claude Code": "Xây dựng với Claude Code",
+    "Claude Platform 101 Quiz": "Bài kiểm tra Claude Platform 101",
+    "Teaching your Agent": "Huấn luyện tác tử của bạn",
+    "Extending your Agent": "Mở rộng tác tử của bạn",
+    "Managed Agents": "Managed Agents",
+    "Data and Privacy": "Dữ liệu và quyền riêng tư",
+    "Who this is for": "Dành cho ai",
+    "Recommended prerequisites": "Kiến thức nền tảng được khuyến nghị",
+    "Course sections": "Các phần của khóa học"
+  },
   "_protected": {
     "Claude Code": [
       "Mã Claude"
diff --git a/src/data/zh-CN.json b/src/data/zh-CN.json
index f89bfda..4d3ce68 100644
--- a/src/data/zh-CN.json
+++ b/src/data/zh-CN.json
@@ -100,7 +100,14 @@
     "Introduction to subagents": "subagents 简介",
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "学习如何在 Claude Code 中使用和创建 sub-agent 来管理上下文、委托任务，并构建保持主对话简洁专注的专业工作流。",
     "AI Capabilities and Limitations": "AI 的能力与局限性",
-    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "了解现代生成式 AI 系统的行为方式，识别意外输出的类型，并实施有针对性的修复。"
+    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "了解现代生成式 AI 系统的行为方式，识别意外输出的类型，并实施有针对性的修复。",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "本课程从零开始教开发者在 Claude Developer Platform 上进行构建，无论您调用过几次 API，还是只通过聊天窗口使用过 Claude。",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "在浏览器标签页里与 Claude 聊天，和把 Claude 构建进可发布的产品之间存在巨大差距。聊天回答完一个问题就结束了，而应用程序会向 Claude 发送结构化请求、交给它工具、让它在真实系统上行动，并为一个用户或一百万用户运行这个循环。Claude Developer Platform 正是为弥合这一差距而存在，这与提示词编写是不同的技能。要从中获得价值，需要理解请求中包含什么、智能体如何决定要做什么，以及成本和限制在哪里。",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "本课程从零开始教开发者在 Claude Developer Platform 上进行构建，无论您调用过几次 API，还是只通过聊天窗口使用过 Claude。我们从第一性原理出发：API 请求包含什么、什么是智能体循环、上下文窗口如何限定 Claude 能看到的范围、工具和权限如何决定它能做什么。这样课程后面的技巧就会成为真正的理解，而不是一份照抄的调用清单。",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "您将发送第一个请求并读取响应，然后为任务选择合适的模型（Opus、Sonnet 或 Haiku），用自己的示例而不是靠猜测来权衡成本与延迟。接着您将手工构建智能体循环，观察 Claude 如何行动、观察和决策，在理解 SDK 的 Tool Runner 替您做了什么之后，再用它收拢那个手写循环。您将通过工具使用扩大 Claude 的能力范围，用扩展思考让它推理难题，并通过工作区、限额和 Console Workbench 让支出保持可预测。",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "课程中段将智能体扩展到您自己的代码之外：在 Anthropic 基础设施上运行的内置工具（网页搜索、代码执行、网页抓取）、把流程打包一次即可跨调用复用的技能、无需编写 schema 就能把 Claude 连接到第三方工具的 MCP 服务器，以及让长时间运行的智能体保持在窗口之内、过了第十轮依然负担得起的上下文管理模式。",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "最后一部分是交接工作。您将学习什么时候自己运行循环、什么时候让 Anthropic 为您运行沙箱化的 Managed Agent，然后端到端构建一个，并在 Anthropic 运行循环并回报时消费事件流。一节独立课程展示如何用 Claude Code 本身来基于 API 构建——这也是课程其余部分之所以重要的原因：要审查智能体替您写的代码，您得知道好代码长什么样。每节课都以可运行的演示结尾，因此每学完一课您都会带着能跑的代码离开。"
   },
   "faq": {
     "Data and Privacy": "数据和隐私",
@@ -1130,6 +1137,29 @@
     "Resource library for instructors": "讲师资源库",
     "Peer learning strategies": "同伴学习策略"
   },
+  "claudePlatform": {
+    "What is the Claude Developer Platform?": "Claude Developer Platform 是什么？",
+    "Your first API call": "您的第一次 API 调用",
+    "Choosing the right model": "选择合适的模型",
+    "The agent loop explained": "智能体循环详解",
+    "What is tool use?": "什么是工具使用？",
+    "What is thinking?": "什么是思考功能？",
+    "Built-in tools": "内置工具",
+    "Skills": "技能",
+    "MCP": "MCP",
+    "Context management": "上下文管理",
+    "What are managed agents?": "什么是 Managed Agents？",
+    "Building your first managed agent": "构建您的第一个 Managed Agent",
+    "Building with Claude Code": "使用 Claude Code 构建",
+    "Claude Platform 101 Quiz": "Claude Platform 101 测验",
+    "Teaching your Agent": "教导您的智能体",
+    "Extending your Agent": "扩展您的智能体",
+    "Managed Agents": "Managed Agents",
+    "Data and Privacy": "数据与隐私",
+    "Who this is for": "适合人群",
+    "Recommended prerequisites": "推荐的预备知识",
+    "Course sections": "课程章节"
+  },
   "_protected": {
     "Claude Code": ["克洛德代码"],
     "Claude": ["克洛德", "克劳德"],
diff --git a/src/data/zh-TW.json b/src/data/zh-TW.json
index 0e957f1..e306138 100644
--- a/src/data/zh-TW.json
+++ b/src/data/zh-TW.json
@@ -100,7 +100,14 @@
     "Introduction to subagents": "subagents 簡介",
     "Learn how to use and create sub-agents in Claude Code to manage context, delegate tasks, and build specialized workflows that keep your main conversation clean and focused.": "學習如何在 Claude Code 中使用和建立 sub-agent 來管理上下文、委派任務，並建構保持主要對話簡潔專注的專業工作流程。",
     "AI Capabilities and Limitations": "AI 的能力與局限性",
-    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "瞭解現代生成式 AI 系統的行為方式，識別意外輸出的類型，並實施有針對性的修正。"
+    "Understand how modern generative AI systems behave, identify types of unexpected outputs, and implement targeted fixes.": "瞭解現代生成式 AI 系統的行為方式，識別意外輸出的類型，並實施有針對性的修正。",
+    "Claude Platform 101": "Claude Platform 101",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window.": "本課程從零開始教開發者在 Claude Developer Platform 上進行建構，無論您呼叫過幾次 API，還是只透過聊天視窗使用過 Claude。",
+    "There's a wide gap between chatting with Claude in a browser tab and building Claude into something you ship. A chat answers a question and the thread ends there. An application sends Claude structured requests, hands it tools, lets it act on real systems, and runs that loop for one user or a million. The Claude Developer Platform exists to close that gap, and it's a different skill from prompting. Getting value out of it means understanding what's in a request, how an agent decides what to do, and where the costs and limits live.": "在瀏覽器分頁裡與 Claude 聊天，和把 Claude 建構進可發布的產品之間存在巨大差距。聊天回答完一個問題就結束了，而應用程式會向 Claude 發送結構化請求、交給它工具、讓它在真實系統上行動，並為一個使用者或一百萬使用者運行這個迴圈。Claude Developer Platform 正是為彌合這一差距而存在，這與提示詞編寫是不同的技能。要從中獲得價值，需要理解請求中包含什麼、智慧代理如何決定要做什麼，以及成本和限制在哪裡。",
+    "This course teaches developers to build on the Claude Developer Platform from the ground up, whether you've made a few API calls or have only used Claude through a chat window. We start from first principles: what an API request contains, what an agent loop is, how the context window bounds what Claude can see, and how tools and permissions decide what it can do. The techniques later in the course then land as understanding instead of a list of calls to copy.": "本課程從零開始教開發者在 Claude Developer Platform 上進行建構，無論您呼叫過幾次 API，還是只透過聊天視窗使用過 Claude。我們從第一性原理出發：API 請求包含什麼、什麼是智慧代理迴圈、上下文視窗如何限定 Claude 能看到的範圍、工具和權限如何決定它能做什麼。這樣課程後面的技巧就會成為真正的理解，而不是一份照抄的呼叫清單。",
+    "You'll send your first request and read the response, then choose the right model for a job (Opus, Sonnet, or Haiku) and weigh the cost-and-latency trade-off on your own examples instead of guessing. From there you'll build the agent loop by hand to see how Claude acts, observes, and decides, then collapse that hand-written loop with the SDK's Tool Runner once you understand what it does for you. You'll give Claude reach through tool use, let it reason through hard problems with extended thinking, and keep spend predictable with workspaces, limits, and the Console Workbench.": "您將發送第一個請求並讀取回應，然後為任務選擇合適的模型（Opus、Sonnet 或 Haiku），用自己的範例而不是靠猜測來權衡成本與延遲。接著您將手工建構智慧代理迴圈，觀察 Claude 如何行動、觀察和決策，在理解 SDK 的 Tool Runner 替您做了什麼之後，再用它收攏那個手寫迴圈。您將透過工具使用擴大 Claude 的能力範圍，用延伸思考讓它推理難題，並透過工作區、限額和 Console Workbench 讓支出保持可預測。",
+    "The middle of the course extends an agent beyond your own code: Anthropic's built-in tools (web search, code execution, web fetch) that run on Anthropic's infrastructure, Skills that package a procedure once and reuse it across calls, MCP servers that connect Claude to third-party tools without writing a schema, and the context-management patterns that keep a long-running agent inside the window and affordable past turn ten.": "課程中段將智慧代理擴充到您自己的程式碼之外：在 Anthropic 基礎設施上執行的內建工具（網頁搜尋、程式碼執行、網頁擷取）、把流程打包一次即可跨呼叫重複使用的技能、無需撰寫 schema 就能把 Claude 連接到第三方工具的 MCP 伺服器，以及讓長時間執行的智慧代理保持在視窗之內、過了第十輪依然負擔得起的上下文管理模式。",
+    "The final section hands work off. You'll learn when to run your own loop and when to let Anthropic run a sandboxed, managed agent for you, then build one end to end, consuming the event stream as Anthropic runs the loop and reports back. A standalone lesson shows you how to build with the API using Claude Code itself, which is also why the rest of the course matters: you need to know what good code looks like to review what an agent writes for you. Every lesson ends with a runnable demo, so you finish each one with working code.": "最後一部分是交接工作。您將學習什麼時候自己運行迴圈、什麼時候讓 Anthropic 為您運行沙箱化的 Managed Agent，然後端到端建構一個，並在 Anthropic 運行迴圈並回報時消費事件串流。一節獨立課程展示如何用 Claude Code 本身來基於 API 建構——這也是課程其餘部分之所以重要的原因：要審查智慧代理替您寫的程式碼，您得知道好程式碼長什麼樣。每節課都以可執行的示範結尾，因此每學完一課您都會帶著能跑的程式碼離開。"
   },
   "faq": {
     "Data and Privacy": "資料與隱私",
@@ -1130,6 +1137,29 @@
     "Resource library for instructors": "講師資源庫",
     "Peer learning strategies": "同儕學習策略"
   },
+  "claudePlatform": {
+    "What is the Claude Developer Platform?": "Claude Developer Platform 是什麼？",
+    "Your first API call": "您的第一次 API 呼叫",
+    "Choosing the right model": "選擇合適的模型",
+    "The agent loop explained": "智慧代理迴圈詳解",
+    "What is tool use?": "什麼是工具使用？",
+    "What is thinking?": "什麼是思考功能？",
+    "Built-in tools": "內建工具",
+    "Skills": "技能",
+    "MCP": "MCP",
+    "Context management": "上下文管理",
+    "What are managed agents?": "什麼是 Managed Agents？",
+    "Building your first managed agent": "建立您的第一個 Managed Agent",
+    "Building with Claude Code": "使用 Claude Code 建構",
+    "Claude Platform 101 Quiz": "Claude Platform 101 測驗",
+    "Teaching your Agent": "教導您的智慧代理",
+    "Extending your Agent": "擴充您的智慧代理",
+    "Managed Agents": "Managed Agents",
+    "Data and Privacy": "資料與隱私",
+    "Who this is for": "適合對象",
+    "Recommended prerequisites": "建議的先備知識",
+    "Course sections": "課程章節"
+  },
   "_protected": {
     "Claude Code": ["克勞德代碼"],
     "Claude": ["克勞德", "克洛德"],
diff --git a/src/lib/constants.js b/src/lib/constants.js
index 312feb0..3f1964b 100644
--- a/src/lib/constants.js
+++ b/src/lib/constants.js
@@ -1304,6 +1304,8 @@ const FLASHCARD_COURSE_MAP = {
   'claude-in-amazon-bedrock': ['cloudDeployment'],
   'google-vertex': ['cloudDeployment'],
   'claude-with-google-vertex': ['cloudDeployment'],
+  // Claude Developer Platform
+  'claude-platform-101': ['claudePlatform'],
   // AI Fluency courses
   'ai-fluency': ['aiFluency'],
   'ai-fluency-framework': ['aiFluency'],
diff --git a/store-assets/RELEASE_CHECKLIST.md b/store-assets/RELEASE_CHECKLIST.md
index 93a64f0..be0b2de 100644
--- a/store-assets/RELEASE_CHECKLIST.md
+++ b/store-assets/RELEASE_CHECKLIST.md
@@ -52,7 +52,9 @@ screenshots in step 2.
 ### 2. Regenerate store screenshots (one command)
 
 Don't hand-capture. `npm run capture:store` drives the **built bundle** with
-Playwright and regenerates the full CWS set into `store-assets/`:
+Playwright and regenerates the full CWS set into `store-assets/` — or run it
+with **zero local setup**: Actions → "Capture store assets" → Run workflow →
+download the `store-assets` artifact:
 
 - `01-translate.png` … `05-exam-safe.png` (1280×800) — translate before/after,
   language picker, in-page AI tutor, flashcards, exam-safe answers