Changelog

Four new advanced lessons complete the OpenCode 2.0 curriculum: Provider registry and streaming retry pipelines, file intelligence with ripgrep streams and language server protocols, plugin hooks with SKILL.md prompt injection, and SQLite storage with cloud sync and session sharing.

Master the next-generation OpenCode 2.0 system: pure Effect-TS runtime layers, append-only SessionEntry event streams, multi-threaded SolidJS TUI, TaskTool subagent orchestration, and the complete OSS contributor handbook with exact code citations.

Practice 180 distinct questions across three 60-question, 120-minute exams. Each form follows the guide's domain allocation and includes single-answer, select-two, and select-three questions; the full set covers all 30 task statements.

Missed questions lead directly to explanations of the deciding concept, including approval prerequisites, isolated skill context, tool selection versus argument constraints, and useful regression tests. Review why each alternative is tempting and which requirement it misses.

Open any of the 180 hard questions through an official-domain drill card, resume attempts from their dedicated URL, and review hard exams, domain drills, and community tests from one IndexedDB-backed history list.

Every question option is now a single rounded button with the letter inline in the text (A. B. C. D.), fully responsive on mobile. Real-test cards show resume, restart, progress, and retake for every attempt state, and the history table gains per-row retake, restart, delete, plus clear-all.

Opening an exam attempt URL directly (or any unknown path) no longer crashes with a React hydration error. Unknown routes now serve a prerendered SPA shell that hydrates cleanly and then renders the real page.

All six OpenCode 2.0 lessons were audited line-by-line against the actual 2.0 source tree. Invented APIs and stale 1.x claims were replaced with verified behavior: transform middleware, SyncEvent event sourcing, the ShareNext queue, FileWatcher direct publish, externals-first skill discovery, and the real permission and PTY internals.

Fixed a broken service worker update that pinned browsers to an old app version after deploys, a resume crash when finishing expired exams, and poisoned browser disk caches that loaded the app as HTML. Assets now carry a fresh cache name and versioned URLs, so one reload brings every browser back to the current build.

Take a reviewed 60-question, 120-minute Foundations exam aligned with the July 2026 guide, including single-answer and select-N items. Resume attempts, flag questions, use the AI tutor, and review answers with focused reading links; Hard Exams 1 and 3 are still in review.

Hard-mock results preserve your answers before help, report raw performance by domain and task, and feed actual responses into study recommendations. Saved attempts survive refresh and are included in progress exports and reset controls.

Read clearer guidance on planning, concrete test feedback, path-scoped rules, and field-level confidence calibration. The hard exams link directly to the section that explains each missed concept.

Real-test exam taking and review cards now show the copy and Ask AI buttons alongside the Scenario highlight, matching every other question surface.

After checking an answer the question sinks to the end of the list. Unanswered questions always stay on top so you work through fresh material without scrolling past already-done ones.

Choose how many questions appear on each page. Pick 200 to blast through a full domain in one scroll, or keep 20 for focused practice.

Filter the question bank by Udemy course or instructor. Deselect sources you find low-quality and drill only the ones you trust.

The Domain Focus tab in Real-Test now shows toggleable instructor pills so you can restrict the draw pool to specific course sources before starting a session.

A single search box covers every question, option, explanation, and section in D1 through D5 plus PRO, with debounced multi-word matching and a single/multi answer-type filter.

Select an option (or options for multiple-select) and hit Check Answer for immediate correct/incorrect feedback with the explanation, related lesson link, and a Try again reset. Session score tracks at the top.

Each checked answer is recorded locally, so bank practice counts toward recommendations and readiness like any other practice.

Results are now ranked by relevance with the question stem weighted highest, and heavily misspelled queries fall back to fuzzy closest-matches instead of an empty page.

One shared action set now lives on all question cards: lessons warmups and reviews, the question bank, practice mocks, exam reviews, and last-step practice and exams. Copy grabs stem, options, answer, and explanation; Ask AI opens the tutor with the full detail prefilled.

Each card has an Ask AI button that opens the AI tutor chat with the full question, options, answer, and explanation prefilled, so you can keep asking follow-ups.

Copy and Ask AI are now a single shared component reused by every question surface, so a fix or improvement lands everywhere at once.

Questions that open with a Scenario header now show the full Scenario plus family name (for example Multi-Agent Research System) as a solid bold amber label, so the preamble is instantly visible and the actual question body stands out. Anything unrecognized renders exactly as before.

Every domain exam now offers a View answer button per question, which reveals the answer and locks that question. The Submit exam button moved to the right end of the card.

Task practice and domain exam cards now have the same copy button as the question bank: question, options, answer, and explanation as plain text.

The AI tutor widget, inline selection chat, and settings now offer a model picker with the full OpenCode Go catalog fetched live from models.dev. Requests go straight to the OpenCode endpoint through our worker.

Highlighting text now opens the ask popover on every page, not just lessons, with touch support, above-or-below placement that stays inside the viewport, and no keyboard trap on phones.

The theme button now switches directly between light and dark. First visits follow your OS preference, and stored system values migrate automatically.

Selecting text now shows a small Ask AI pill with no backdrop dimming. The full chat opens only when you tap it, and the pill dismisses on scroll, Escape, or tapping elsewhere.

Mixed practice taking and review cards now show the Scenario highlight plus copy and Ask AI buttons, matching every other question surface.

Agentic Architecture, Tool Design and MCP, Claude Code, Prompt Engineering, and Context Management each get a study path that matches the official 27/18/20/20/15 split, linked in order from the new /last-step-final hub.

Server-side compaction request shapes, context editing, the memory tool, prompt caching mechanics, model-window claims, and the output_config versus output_format transition are gone from the editions. Each affected page carries a note explaining why those sections are absent, and the exam-tested pattern (the case facts block, lost-in-the-middle, tool-result trimming, structured errors, calibration, provenance) stays.

The decision-rules and authoritative-mechanism layers that expanded the reference pages are dropped from the editions, leaving the readable teaching core: intro, subsections, distinctions, traps, a rewritten crash-recovery/scratchpad section, and a scrub of the 5.1 context-management intro to pattern-level explanation.

The full /last-step pages with the complete API surface, rules, and grounding remain as the reference; the editions link back and forth via updated prev/next navigation and appear in the sidebar and header.

The previous version listed hundreds of separate decision rules per page, each with its own mechanism, boundary, and wrong-answer breakdown, plus a second parallel explanation of the same material underneath. The same ground is now covered as continuous explanation you can read start to finish: each concept introduced once, in the order that makes the next one make sense, with the boundary that decides exam answers woven into the sentence rather than bolted on as a labelled field.

Twenty-five callouts sit at the exact point in each argument where a plausible mistake becomes attractive: raising the iteration cap when the loop exits early, forking to escape stale context, reaching for a bigger context window when a review comes back shallow, detecting a violation after the tool already ran. Each one says why it tempts and what it actually fails to do.

Each example carries the decision it demonstrates, not just the syntax: the loop with an explicit branch for every stop reason, an executor that keeps failures in-band with a retryability category, hub-and-spoke coordination that emits parallel work in one turn, a hook set showing what can be prevented versus only rewritten, and a two-layer review that catches what a single pass structurally cannot.

Which phrases in a long question actually decide the answer, how to spot a stem that has already cleared the downstream components so only the coordinator remains, and the one question worth asking when twenty seconds are left.

Each of the 30 task statements across the five domain guides carries 8 questions drawn from the same scenario-based pool the practice and mock exams use, selected by relevance to that specific task rather than to the domain as a whole. Answer, check, and you get the reasoning plus a note on every wrong option before moving on. Each answer is recorded immediately, so an abandoned run still counts toward your progress and recommendations.

The exam at the foot of every guide is sized to exactly what that domain contributes to the real 60-question paper: 16 questions on Agentic Architecture, 12 on Claude Code, 12 on Prompt Engineering, 11 on Tool Design and MCP, and 9 on Context and Reliability. Answers are held back until you submit, you get a scaled score against the real 720 pass mark, and each attempt draws a fresh paper from a larger pool so a retake is genuinely different.

The final domain now carries 179 distinct decision rules across all six tasks: protecting transactional facts from summarisation, defeating positional degradation, calibrated escalation and ambiguity handling, structured error propagation with partial results, holding precise references across long codebase exploration, calibrated human review, and provenance that survives synthesis. An authoritative layer of 203 mechanism sections documents the current context-management surface, including the server-side compaction strategy with its trigger and summary shape, tool-result and thinking-block clearing, the memory tool, and the citation and search-result blocks that bind a claim to its source.

Every exam domain has a full-length guide rather than a summary card, so the whole 27/20/20/18/15 blueprint is covered at the same depth. Documentation references across all five pages were re-verified against the current documentation hosts.

The six Prompt Engineering tasks now carry 186 distinct decision rules covering explicit criteria over vague instruction, example design that carries its own reasoning, the current schema-enforcement surface including the configuration field and strict tool use, retry loops that separate a fixable shape error from information the source never contained, the full batch contract with its timing and correlation rules, and independent review over self review. An authoritative layer of 198 mechanism sections documents the exact fields, limits, and outcome states, all verified against the current documentation.

The six Claude Code tasks now carry 177 distinct decision rules covering memory scoping, the unified skills system, conditional path-scoped rules, planning versus direct execution, refinement technique selection, and headless pipeline runs. An authoritative layer of 230 mechanism sections documents the exact file locations, frontmatter fields, permission modes, and command-line flags, with every configuration sample rendered as a real syntax-highlighted block.

The five Tool Design tasks now carry 131 distinct decision rules with mechanisms, answer-flipping boundaries, recurring specifics, distractor anatomy, and scenario mutations, alongside an authoritative layer of 123 mechanism sections covering the documented tool, error, choice, MCP, and built-in tool surfaces. Every code sample renders as a real syntax-highlighted block with a copy button, and identifiers appear as inline code throughout.

The seven Agentic tasks now expose 255 distinct decision rules with their mechanisms, answer-flipping boundaries, recurring specifics, distractor anatomy, and scenario mutations. A separate authoritative layer covers the complete documented API and SDK surface, terminology changes, ownership boundaries, production walkthroughs, and build exercises, with sticky task navigation and collapsible sections for a page of this depth.

Agentic loops and the stop reason contract, hub and spoke orchestration, subagent invocation and the metadata that keeps attribution alive, prerequisite gates and structured handoffs, PreToolUse versus PostToolUse hooks, fixed pipelines versus adaptive decomposition, and resume versus fork versus fresh start with an injected summary.

Descriptions as the selection interface and the schema fields that gate execution, the four error categories with valid emptiness kept off the retry path, tool distribution with role scoping and enum consolidation against every documented choice mode, MCP configuration scope with credential expansion and the protocol primitives behind it, and the built-in search, read, edit, and shell tools with their permission boundaries.

Why memory files concatenate while settings layers override, skills and commands as one mechanism, path scoped rules for conventions that span directories, plan mode as read only exploration, the refinement ladder from examples to tests, and the print mode flags that make headless runs deterministic.

System prompt composition and placement, what examples can and cannot teach, the ladder from asking for JSON to enforcing a schema, validation loops that feed back the specific failure, when batching is safe and when it breaks a merge gate, and per item passes plus a separate integration pass.

Budget composition and the quality ceiling inside any window, the three valid escalation triggers, structured error propagation without silent suppression, scratchpads and manifests against context degradation, segment level calibration instead of one aggregate number, and provenance that survives synthesis.

Each task lists the Anthropic documentation and engineering articles it relies on, plus the lessons on this site that go deeper, so any claim can be checked at source before you rely on it in production.

The Last Step overview now teaches the reasoning layer directly: the twelve recurring decision axes, the wording that narrows the mechanism, the eight distractor styles, and a six step algorithm for scenarios you have never seen.

The Context Window lesson now teaches 200K (Haiku 4.5 / Sonnet 4.5 / Opus 4.5) and 1M (Sonnet 5 / Opus 5 etc.) as model-dependent, with enablement via [1m], standard pricing, Token Counting API, and server-side compaction. The 200K-only warmup was rekeyed to match.

The CI/CD lesson adds deterministic --output-format json + --json-schema (draft-07, structured_output validated and retried, total_cost_usd, jq .structured_output gate) and why Batches 24h SLA is the blocking-check distractor, plus --bare/-p/10 MB cap/exit codes/stream-json notes.

Configuration adds the full hook-type event reference table, matcher semantics, and I/O contract with diagram. Wrapped with the UPDATED ribbon.

Qualified remaining unqualified 200K paragraphs in backbone lessons and fixed the Sonnet 4.6 mythos table (1M, not 200K) and the CI/CD registry title (--pref does not exist).

New questions cover 200K vs 1M by model and --output-format json + --json-schema contracting vs probabilistic prompt suppression.

Start a 20-question mock for any of the five official exam domains (D1-D5) directly from the Practice page. Non-proctored, instant feedback per question, and a review screen with explanations and source attribution for every question.

A 60-question blueprint-weighted mock (16/12/12/11/9 across D1-D5) that mirrors the real exam's 27/20/20/18/15 split at a 60-question scale, with a scaled /1000 score display.

The mock engine tracks every question it has served per pool in your local database and never repeats one until the pool is exhausted, then resets the pool and reshuffles. Starting again always yields new questions.

A deduplicated bank of 9,561 real exam-style questions (gathered from 28 community prep courses, 3,000 cross-course duplicates removed) now powers all mocks, grouped by the five official domains with explanations, feedback, and source attribution on every question.

Every exam-domain lesson gained 3 new warmup and 3 new end-of-lesson questions drawn from the community bank (498 total), and existing domain exams were seeded with 673 more unique real questions. All additions are unique site-wide and clearly separated from the original authored bank.

Analysis of the real question bank surfaced seven uncovered topics, now fixed with new sections: programmatic loop guardrails, subagent failure recovery, workflows vs agents, PostToolUse hooks, batch parallel tool design, community vs custom MCP servers, and the Messages API MCP connector.

All pages now reflect the current certification program: the exam is CCAR-F (formerly CCA-F) at $125, part of a four-tier family with CCAO-F, CCDV-F and CCAR-P. Updated across landing, blueprint, exams and FAQ structured data: 12-month validity with free renewal assessment, the 14/30/90-day retake policy, Pearson OnVUE or test-center proctoring, registration via Partner Academy, and the real format - 60 items mixing multiple-choice and multiple-response, framed inside 4 scenario sets drawn from a bank of 6.

The remaining domains got the same question-backed treatment: the Claude Code hook script contract, model selection precedence, session resume and checkpoints, skip-permissions guidance, Agent SDK permission and budget controls, JSON prefilling, negative constraints in system prompts, and confidence drift-detection sampling.

All 16 sections added in this release are now wrapped in a rounded accent-bordered callout with an UPDATED AUG 2026 flag pinned to the top-right corner, so you can instantly spot freshly added material inside any lesson. Works in both light and dark themes.

Every mock and quiz question now has an Explain This button that opens a concise AI explanation of the tested concept, with correct answer context. A Teach me from first principles button expands the same dialog into a full-length breakdown. Answers are cached locally so repeat views are instant, and an offline fallback always shows stored notes.

Every lesson is getting a spoken-style narration (voice alba) written as a real explanation, not a text readout. A themed audio player sits on lesson pages with play/pause, seek with buffered progress, playback speed from 0.75x to 2x, volume, 10 second skip, and download.

A new Question Bank page lists every one of the 9,561 deduplicated exam-prep questions by official domain, with search, pagination, correct answers, explanations, Concept Coach, and a link to the most relevant lesson section for every question.

Mock exams can now be set to Real (community exam-prep), Authored, Mixed, or Auto. Your choice persists per browser, and the result screen shows exactly what pool served you.

Vendor names are gone from review screens. Every question now links straight to the most relevant internal lesson section, and explanations are remapped to the actual shuffled option letters you saw.

Context-window and token-management lessons now list Claude Sonnet 5 and Claude Opus 5 with their 1M-token windows and 128K max output, matching the current model lineup and its API ids.

Lessons that enumerate the model lineup now mention Claude Fable 5, the Mythos-class frontier model above Opus with a 1M-token window, including a note that access is currently suspended under US export controls.

New AI study assistant with a model-selection popover and diagram-based explanations to help learners work through CCA-F concepts.

Trace the evolution from prompt to context, harness, loop, and graph engineering. Learn nodes, edges, state, workflow topologies, LangGraph and Claude Agent SDK patterns, loop-versus-graph decisions, and practical triage systems where agent organization becomes programmable.

Every lesson in the new course now includes the explanatory diagrams from the original graph engineering discourse: the chain-versus-diamond wall-clock comparison, the starter graph with its review loop, the composed research-and-publishing graph, the anchors diagram, the context-graph ledger schema, and more. All diagrams rebuilt in the site theme for light and dark mode. Added citations and a references section to every lesson, grounded in the July 2026 X threads plus Anthropic's engineering posts, LangGraph, and the Bun port write-up.

Full Remotion v4 project in video/ with 16 compositions: WhatIsClaude lesson (30s) + 14 domain overviews (20s each) + Practical Exercises. Slide components: TitleSlide, ContentSlide, CodeSlide, DiagramSlide. Custom transitions (fromRight/fade/zoom) and SyncedAudio wrapper for voiceover sync.

CodeBlock component with Shiki-style syntax coloring, line-numbering, and frame-based line highlighting. Step through code lines one at a time with amber background highlight — ported from Animotion's approach. Supports title bar, selected lines per frame, smooth Reveal.js-inspired reveal.

generate_audio.py script uses Voicebox desktop API at localhost:17493 for high-quality neural TTS. Supports --voice preset selection, --reference-audio voice cloning (3-5s clip), --speed control, --combine for full-lesson concatenation. Falls back to silent WAV when Voicebox is unavailable.

domain-data.ts with all 14 CCA-F domains, real exam weights, lesson counts, colors, and bullet-point overviews sourced from content-registry.ts. Each composition auto-chunks into 3-bullet slides with title + grouped content + summary recap.

Added 2 more font size steps (X-Large 24px, Huge 26px) for a total of 7 levels. Default remains 16px. Control in sidebar footer now offers finer-grained scaling from Small (14px) to Huge (26px).

Replaced simple bar chart with an archify/baoyu-inspired inline SVG showing all 5 domains with gradient-filled proportional segments, percentage callouts, and detailed description cards — all responsive and dark-mode compatible.

Updated to cover adaptive thinking (`thinking: {type: "adaptive"}`) as the recommended approach, the `effort` parameter (`output_config: {effort: "high"|"xhigh"|"max"}`), always-on thinking on Fable 5/Mythos 5, thinking display defaults, and `thinking_tokens` in usage API.

Updated JSON Mode lesson with `output_config.format.type: "json_schema"` as the canonical approach, SDK `parse()` method, deprecated `output_format` param, and strict tool use GA.

Added new appendix section covering the July 2026 stateless protocol revision: no initialize handshake, `server/discover`, MRTR, MCP Apps, TTL caching, deprecated Roots/Sampling/Logging.

Updated for Streamable HTTP as the standard transport with `Mcp-Method` and `Mcp-Name` headers for load-balancer routing. SSE officially deprecated as legacy transport.

Added 7 new sections: skeptical trust (treat all tool outputs as adversarial), containment over supervision, three-layer prompt injection defense, human gate for irreversible actions, adversarial input testing, credential scoping, and logging reasoning not just outputs.

Dedicated page listing all 9 courses with icons, descriptions, and lesson counts. Linked from breadcrumbs and main nav.

Changed invalid `<Link to="/exams/mock">` to `<Link to="/exams/$slug" params={{ slug: "mock" }}>` in index.tsx, readiness.tsx (x2), common-mistakes.tsx, and practice-mixed.tsx. This was causing Radix Slot invariant errors when asChild buttons rendered.

Added 2 more font size steps (X-Large 24px, Huge 26px) for a total of 7 levels. Default remains 16px. Control in sidebar footer now offers finer-grained scaling from Small (14px) to Huge (26px).

Four-layer progression: The Evolution of AI Engineering (overview), Prompt Engineering for Loop Engineers (with pointers to full Prompt Engineering course), Context Engineering for Loop Engineers (with pointers to full Context Engineering course), Harness Engineering: Single-Run Reliability (Anthropic's patterns, ACI, eval gates, Initializer+Coding Agent), Harness Engineering: Advanced Patterns (Generator-Evaluator, feature lists, multi-agent patterns), Loop Engineering: System Design (five building blocks, verification, stopping conditions, state persistence), Loop Engineering: Implementation (Claude Code /goal, Codex automations, OpenCode cron, real triage/CI/PR patterns), and Ecosystem & Career (tools, MCP ecosystem, becoming a loop engineer).

Each lesson includes a detailed diagram: four-layer stack, prompt-in-loop flow, context compaction across iterations, harness boundary architecture, Generator-Evaluator three-agent architecture, full loop system design, platform comparison, and ecosystem map.

Lessons 2 and 3 include detailed pointers to the existing CCA-F Prompt Engineering (8 lessons) and Context Engineering (10 lessons) courses, creating a cohesive learning path.

Rewrote all 10 lessons from scratch targeting dev contributors. Each lesson starts from the core abstraction, traces through actual source code, and includes 2-3 inline SVG diagrams using the dgm-* design system. Covers: architecture, install/setup, agent system, configuration (9-layer merge), tools & file operations, session management, permissions (ask/reply/evaluate), skills & plugins, MCP integration (local/remote/OAuth), CLI workflows, and VS Code extension.

Every lesson now includes 2-3 diagrams showing architecture (layered stack), workflows (pipelines with arrows), state machines (agent loop, session lifecycle), and sequences (tool execution, MCP handshake) — all themed via CSS classes for dark/light mode compatibility.

Rewritten for developers contributing to the opencode repo. Uses we/you, names specific files and line ranges, explains first principles before details, and avoids tutorial language.

A comprehensive journey from single-agent fundamentals to multi-agent production systems: agent evolution, architecture (harness, two-axis map), perception & memory, reasoning & planning, action & tools, reflection, single-agent patterns, multi-agent overview, orchestration patterns, coordination, governance (HITL/HOTL/AFK), and production engineering (evaluation, observability, benchmarks).

Four advanced lessons added to the Context Engineering domain: the context engineering stack (core + harness), six-level context sources taxonomy, context management & orchestration (selection, writing, compression, isolation), and context evaluation, observability, governance & operations.

Three questions per lesson (warmup, mid-lesson, end-of-lesson) covering all 16 new lessons, with scenario, tradeoff-analysis, architecture-review, and multiple-select question types.

Every concept is explained through concrete examples from real agent tools and frameworks so you can apply what you learn directly to your own projects.

The Token Management lesson now embeds a calculator directly under "What Is a Token?", type or paste text and watch it split into colored token chunks live, illustrating how subword tokenization works.

Choose between the legacy tokenizer (Sonnet 4.6, Haiku 4.5, Opus 4.6) and the current one (Opus 4.7, Opus 4.8, Fable 5, Mythos 5) to see Anthropic's documented ~1.0-1.35x token-count difference applied to your text.

There's no public client-side Claude tokenizer, token_counts are only available via the real /v1/messages/count_tokens API. The calculator says so directly rather than implying production-accurate counts.

LessonViewer can now mount a React component at an exact marker inside raw lesson HTML, instead of only before/after the whole lesson body like the existing quiz embeds, reusable for future interactive widgets.

81 of 83 multiple-choice questions in the core bank had their correct answer at position A, with throwaway distractors, gameable by always picking the first option. All 81 are now shuffled to a random position with matching, rewritten explanations.

The Udemy-sourced question bank (1,184 questions) had only 543 unique IDs, 641 questions silently became unreachable whenever a same-ID sibling was already chosen for an exam. Every ID is now unique.

The default single-answer-only filter only allowed presentational type 'multiple-choice', excluding nearly all 'scenario' questions even though they're also single-answer. The filter now checks actual answer count, not presentation style.

Found and rewrote 14 Udemy-bank questions with blank explanation fields (and one with a flatly wrong correct answer) surfaced once they entered the wider exam pool.

The Exit button during an exam now offers a direct "End Exam Now & See Score" option, instead of a confusing two-step Exit → Review → Exit-again flow to finish before answering every question.

On a lesson page, the sidebar now shows only that domain's chapter list (with the current lesson highlighted) instead of the full Exam Domains / Courses / Navigation / Quick Links tree every time.

Reopening the sidebar on a lesson page was immediately undone by the auto-close effect, which re-fired every time the sidebar's internal setOpen identity changed (i.e. on every toggle). It now only auto-closes once per lesson visit.

The floating edge toggle shown when the sidebar is closed is now larger with a subtle shadow, so it's easier to spot on lesson pages.

Agent Loops' "200K context limit" callout now correctly notes the limit varies by model (Haiku 4.5: 200K, Opus 4.8 / Sonnet 4.6: 1M), found during a content-accuracy audit.

Increased the diagram's viewBox and spacing so the FAN-OUT, PIPELINE, and ROUTER sections no longer crowd each other.

The ROUTER section title sat almost on top of the Billing node; rows were shifted down with proper clearance so the title is fully clear of every box.

Reduced stroke widths to 1px, dropped bold font-weights to 400-500, and switched accent colors to muted rgba tones for a calmer, native-feeling diagram.

Every diagram in the course now uses the new .lesson-diagram system: ray.so-style squircle cards with themeable grid backgrounds, OOAD-shaped nodes with proper colors, and smooth bezier-curve arrows instead of straight lines. The token-management lesson also has a new cylindrical context-window gauge (range-element look) explaining token allocation.

The Claude Code agent loop SVG was shrunk from 640×250 to 520×200 with compact nodes and legible text, fixing the oversized-diagram complaint on mobile.

The permission-request block in core-capabilities now renders as a dark terminal-styled pre block with green additions, red deletions, highlighted keys, and a Claude Code-like header, replacing the old ASCII box-art.

New 5-step numbered journey section (diagnose → path → practice → mock → ready) with time estimates and a connecting spine. Trust band contrasts proctored conditions, real captured data, and evidence-backed recommendations against generic Q&amp;A sites.

The top navigation bar now only appears on the landing page. Inside the app (lessons, dashboard, exams), all actions are in the sidebar. Mobile shows a minimal fixed header with logo and sidebar toggle only.

Theme toggle and font-size controls now live in the sidebar footer so they are always reachable even without a top header.

Both FAQPage schema.org blocks updated from stale '12 domains / 72 lessons / 715 questions / 65Q-130min-75%pass' to the verified '5 domains / 116 lessons / 800+ questions / 60Q-120min-720pass' facts. Removed the incorrect 'multiple select' question-type claim, the real exam is single-answer MC only.

Original, exam-grade scenarios covering the patterns the real exam leans on: application-layer policy enforcement vs. prompts, per-segment confidence validation, filtering stale tool_results on resume, schema redundancy for math consistency, resilient catch-all enums, the limits of retry loops, tool_choice for execution order, shared vector stores vs. daisy-chained logs, goal-oriented delegation, and structured escalation handoffs.

Distilled the Anthropic Cookbook recipes and production-architecture material into an internal reference so our scenarios mirror the constraint tradeoffs (latency, accuracy, cost, compliance) the exam tests.

Added genuine, exam-aligned warmups so all 86 exam lessons now have four or more, closing 24 lessons that previously had none and ~50 that had only two. Each question is written to the verified CCA-F facts, not filler.

Warmups are shuffled on each visit and lessons with four or more surface a fresh subset (3 of N) each time, so revisiting a lesson no longer shows the same static set.

Added a model deprecation timeline with verified end-of-life dates (claude-3-haiku, Sonnet/Opus 4.0, Opus 4.1) and context on legacy generations including Claude Instant, so older-model exam questions are unambiguous.

Warmups about the system prompt now match what the page actually teaches, message roles, the top-level system parameter, alternation, caching, and the security boundary.

Every release now records its immutable deployment URL here, so you can always open the exact version that shipped with a given update.

Our own client-side tracking SDK now records your entire learning session, reading depth, scroll, time-on-task, active/idle, page views, and every warmup, quiz, practice, diagnostic and exam answer. Stored locally (private) with optional cloud sync.

Evidence-backed recommendations rank what to study next using recency-weighted mastery, repeated-miss and overconfidence detection, and scenario-vs-recall gaps, each with a 'master this topic → open the lesson → try again' action, weighted to the official 27/20/20/18/15 exam split.

Real-exam proctoring: detects tab-switching, copy/paste, right-click, developer tools, fullscreen exit and blocked shortcuts; logs violations, shows an integrity score, and auto-submits on repeated serious violations. Scores scale to the CCA-F 1000-point range (720 = pass).

Dashboard, progress and readiness now reflect your actual captured activity, real study time, streaks, per-domain mastery and reading progress. No placeholder numbers.

The in-app EPUB reader now initializes reliably and resizes in place (no more blank viewer), with a corrected page-position readout.

Resolved the blank-PDF-in-production issue and shrank the file via self-hosted fonts; the in-app reader defaults to a fast HTML view with PDF/EPUB downloads.

Refreshed model IDs (Opus 4.8 / Sonnet 4.6 / Haiku 4.5 / Fable 5), migrated structured-output examples to the current API, and reconciled the lesson count to 116 across the site and book.

Comprehensive deep-dive lesson covering the new Mythos-class models, architecture, safety guardrails, SWE-Bench Pro 80.8%, Project Glasswing, and the June 12 US government suspension. Added to 'Latest Updates' domain with 10 practice questions and integrated across flashcards and mock exams.

Added 'Beyond the Main Tiers: Mythos-Class Models' section with comparison table, safety architecture explanation, and link to the dedicated lesson.

Named @page rules for chapter-start/part-start sections, opening pages of chapters and parts now have zero top margin for cleaner layout.

Fixed production build pipeline, old 21.9 MB PDF was stale. Replaced with fresh 16.4 MB version containing all 104+ lessons.

Fable/Mythos lesson added as Part V (Appendix) in the HTML/EPUB/PDF book generation, shows as chapter 116 in the compiled book.

This very page! A dedicated timeline of every feature, fix, and content update, ordered newest first.

Mock exams now strictly follow official CCA-F domain weights (27/20/20/18/15). Each exam draws exactly the right number of questions per domain, matching the real exam proportions.

New comprehensive strategy guide page with time management tactics, question elimination techniques, and domain-specific tips.

Exam results now show performance broken down by each of the 5 official domains, pinpoint exactly which areas need more study.

If you consistently score above 85%, mocks automatically sample harder questions (including pro-level ones) to keep challenging you.

Every question now includes a wrong-answer explanation for each incorrect option, not just why the right answer is right, but why each wrong answer is wrong.

Questions that were tagged at the wrong difficulty level or domain have been redistributed. The question bank is now more representative of actual exam difficulty.

Ambiguous, misleading, or duplicate questions replaced with clearer alternatives. Each rewrite was verified against Anthropic's official documentation.

New 'Common Traps' page cataloging the most frequently missed question patterns, with strategies to avoid each one.

Full audit and fix: skip-to-content link, aria labels on all interactive elements, proper landmark regions, focus indicators, reduced-motion support, and color contrast improvements.

Comprehensive test suite covering auth flows, lesson navigation, exam functionality, accessibility (axe-core), and Supabase progress sync.

Vercel-style near-black dark theme applied site-wide. Better contrast ratios, consistent card surfaces, and improved code block readability in dark mode.

Quiz card height clipping fixed, sidebar collapse behavior improved on mobile, table overflow scrolling on narrow viewports.

Entry exam covering all 5 domains that maps your strengths and weaknesses before you even start studying. Generates a personalized study plan with estimated score prediction.

Based on diagnostic results, the study plan reorders lessons to prioritize your weakest areas while respecting prerequisite chains. Updates as you progress.

New composite score (0-100) that combines mock exam performance, flashcard retention, and lesson completion rates into a single readiness metric.

Exam results now highlight specific lessons that are dragging down each domain score, with direct links to the relevant material.

Flashcards now use the full SM-2 algorithm, scheduling reviews based on your performance history. Cards you consistently recall appear less frequently; cards you struggle with appear more often.

Advanced pro-level questions added to the pool, harder, multi-step scenarios that test deep understanding rather than recall. Filterable in practice mode.

Interactive graph view now shows prerequisite chains, concept dependencies, and domain cross-links. Hover a node to see its connections highlighted.

Replaced analogy-driven explanations with mechanism-first writing across 49 lessons, focusing on how and why things work, not just what they're like.

Every lesson now includes a CCA-F Exam Tips section with likely scenario questions, key concepts to memorize, and common pitfalls tested on the real exam.

Full test coverage for the adaptive study plan algorithm, validates prerequisite ordering, weak-area prioritization, and plan recalculation after progress updates.

Fixed a bug where quiz options used position-based ID mapping instead of content-based mapping, causing incorrect shuffling behavior across quiz attempts.

Corrected scoring edge case where partially-completed mocks showed inflated scores due to NaN handling in unfinished sections.