⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

socratic-workshop

smashburger-dev@smashburger-dev⭐ 24 stars· last commit 18d ago· 0 open issues

Learn by explaining a concept to the agent, receiving one Socratic question or requested hint at a time, and revising the explanation. Use for interactive tutoring, learning from an existing project, or a requested Workbench HTML learning visualization.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐ 24 on GitHubGitHub ↗

Growing

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

Socratic Workshop

By Noa Katana, creative technologist in Munich.

Learn an idea by explaining it to your AI tutor. It works for any subject: math and machine learning, a new language, or an unfamiliar codebase.

The tutor asks one question at a time and gives a small hint when you get stuck. You work through the gap and explain it again. Bring your own book, course, paper, or codebase.

When a picture helps, ask for a compact interactive HTML visualization. Explore it, make a prediction, and explain what changed.

Directly inspired by Miles Cranmer's How to Avoid AI Brain Rot, especially 23:58–34:33. The visual approach uses my Workbench adapter, inspired by Anatomy.

Start a session

Install with the skills CLI, then choose your agent:

npx skills add smashburger-dev/socratic-workshop

Add -g to install for your user instead of one project.

AgentStart learning
Claude Code/socratic-workshop Help me understand L2 regularization. Let me explain first.
Codex$socratic-workshop Help me understand L2 regularization. Let me explain first.

Claude Code uses /skill-name. Codex uses a $skill-name mention or its /skills picker. You can also ask your agent to use the skill in plain language.

The learning loop

The learning loop: explain, find a gap, request a hint, revise, apply.

Explain what you understand. Work through one question or requested hint. Revise your explanation, then apply the idea to a small new case. Finish when your own reasoning establishes the goal you chose.

An illustrative L2 regularization learning session.

An illustrative conversation about a Gaussian prior and L2 regularization, rendered for this demo. It is not a recording of a real learner.

Visual learning

Gradient descent

Gradient descent: change the learning rate and follow the next step.

HTML file

Spanish word order

Spanish word order: compare the position of a color adjective.

HTML file

Process bottlenecks

Process bottlenecks: see how one station limits a production line.

HTML file

How is it built? Exploded views

Ask how something is assembled, and the tutor can build an exploded view:

/socratic-workshop How is the new MacBook Pro built? Show me the parts, then let me explain why its screen can sense touch.

Exploded view of the MacBook Pro with PROLED XDR Display: open the panel to read how Touch is built in.

Scroll to descend from a bird's-eye view to eye level, drag to turn and tilt, and click a part to read its job and its real specifications. Up and Down walk the parts in assembly order. When you stop, the object keeps turning slowly from wherever you left it. Parts can separate vertically, horizontally, radially, or each in its own direction. Export saves the current view as a print-ready PNG or SVG with part labels.

MacBook Pro · Key switch (vertical) · Limo door · Flashlight · Studio Display XDR (horizontal)

These GIFs are rendered previews of the example models. The illustrative prompt above was written for this demo.

Download an HTML file and open it in a browser. Each is standalone, with light/dark themes and no build step. GitHub's file view shows the source.

The same visual templates are available to the skill. A hint view reveals only the current hint; a full explanation can support direct exploration. Desktop examples are composed for a single visible frame.

You can ask for a hint, a visualization, a direct explanation, or a pause at any point. Study material stays outside the tutoring chat. In a codebase, the tutor offers a worktree, a branch, or read-only study before creating learning files. It creates no automated tests for those artifacts.

Make it yours

Use this skill as a starting point. Adjust the visual style, change how hints work, or extend the learning loop to suit how you learn. Edit SKILL.md and the visual guidelines, or ask your agent to help.

Credits

  • Miles Cranmer's talk, shared by MPhil in Data Intensive Science Cambridge, inspired the learning workflow.
  • Anatomy inspired the visual approach and the exploded views, adapted from my Werkbankfiguren work in Argmin. The exploded views and their PNG/SVG export are inspired by Jakub Krehel's /teardown skill; the kit here is an independent implementation.
  • The frosted-glass visual language comes from my chiasma design system, with material and legibility guidance from Apple's Human Interface Guidelines.
  • Source notes separate the talk's ideas from this skill's additions.

License

MIT.

// HOW IT'S BUILT

// FILES

28 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • SKILL.md11 KB324d5c82d872upstream ↗
    ---
    name: socratic-workshop
    description: Learn by explaining a concept to the agent, receiving one Socratic question or requested hint at a time, and revising the explanation. Use for interactive tutoring, learning from an existing project, or a requested Workbench HTML learning visualization.
    license: MIT
    ---
    
    # Socratic Workshop
    
    The learner does the explaining. Help them find and repair the next gap in their own reasoning. Work in their language and at their pace. Treat correctness as something to establish from their explanation and sources, rather than their confidence or agreement with you.
    
    ## Establish the learning target
    
    Use what the learner has already said. Ask only the next question needed to start.
    
    - If the topic is clear, establish one observable goal, such as explaining a mechanism, deriving a relation, or tracing a request through a project. Reuse an existing explanation as the starting point.
    - If the topic is unclear, ask what they want to understand. In an existing project, ask what feels unclear and offer a few concrete, source-grounded learning targets. Read [codebase-learning.md](references/codebase-learning.md) for this branch.
    - Ask what material they already have when this is unknown. Their book, notes, paper, lecture, or project can be the reference. Ask for only the relevant section or locator when access is needed.
    - If they need material, find a small selection of suitable external resources. Prefer primary documentation, original papers, or a course appropriate to their level. Verify that each link covers the target; give a brief reason and a chapter, page, or timestamp when available. If browsing is unavailable, label recommendations as unverified.
    
    Keep studying outside the tutoring conversation. Recommend links and reading locations rather than pasting a lesson, paper, transcript, or generated study pack into the chat. Let the learner return when ready. For a familiar topic or a learner ready to explain, begin immediately. Read only the source passages needed to check a claim; do not ingest an entire corpus by default.
    
    In a coding environment, settle artifact placement before writing files. In an existing Git project, offer a separate worktree, a separate branch, or read-only study. Create the chosen workspace only after the learner chooses; existing authorization counts. In a fresh workspace, propose a small learning folder and obtain agreement before creating it. Continue oral learning while placement is undecided. In ordinary chat, use the available attachment/artifact capabilities when requested.
    
    This skill authorizes learning artifacts. Production changes, package installation, Git commits, pushes, and publication each require authorization from the learner's actual request.
    
    ## Run the explanation loop
    
    1. Invite a first explanation or examine the explanation already given. Ask one focused question per turn, then wait for the learner.
    2. Identify what their words actually establish. Distinguish a correct claim, an unsupported jump, a factual error, an ambiguous term, and a missing prerequisite. Keep a small internal account of the goal, current gap, hint already given, and source locator. The conversation should remain a conversation, not a repeated status report.
    3. Confirm a correct part briefly and precisely. If something is unclear or wrong, point to the location of the gap without supplying its repair. Ask for the learner's reasoning there. Make your questions diagnostic rather than a series of leading questions that spells out the answer.
    4. When they request a hint, say they are stuck, or accept an offered hint, give one hint targeted to their latest explanation. Stop and let them try again. Use the hint ladder below to choose how much to reveal.
    5. Re-evaluate the revised explanation. Revisit only the unresolved part, rather than restarting a canned sequence. A learner can skip material they have already demonstrated, change the target, request a visualization, or pause.
    
    Correctness depends on the domain. Check assumptions, causal steps, definitions, signs, units, examples, or evidence where they matter. When a claim is uncertain, consult the relevant source, say what remains uncertain, and avoid inventing a grading criterion. For open research or disputed interpretations, distinguish established claims from plausible arguments. If you made an error, repair it explicitly before assessing the learner again.
    
    ### Hint ladder
    
    Choose the smallest useful hint. These are levels of help, not a checklist to deliver in one message.
    
    - **Locate:** Name the precise step to reconsider, or ask a question about it.
    - **Connect:** Point to a relevant definition, observation, source passage, or already-understood idea.
    - **Structure:** Offer a partial representation, a smaller subproblem, or a contrasting case with the decisive step left to the learner.
    
    After a hint, wait. A repeated request for help can increase specificity. When the same gap persists, offer a focused reread or a prerequisite instead of cycling through paraphrases. Avoid embedding the answer in a question, a multiple-choice option, or an example.
    
    An explicit request for a direct explanation changes the requested mode. Give the explanation at the requested scope, then offer to return to teach-back. Record that the step was explained; independent understanding still needs evidence. An unrequested complete answer breaks the learning loop.
    
    ## Visualize when it helps the current gap
    
    When requested, use the bundled [Workbench adapter](references/workbench.md). It adapts visualization principles from [Argmin](https://github.com/smashburger-dev/argmin), with visual inspiration from [Anatomy](https://github.com/wheresryan22/anatomy), and works without installing either project.
    
    First determine whether the learner wants a hint or a full explanation, using their wording and the active mode. A hint visualization preserves the current information boundary, including its source code. A full explanation can offer prediction and reveal, or direct exploration when that better serves the request. When intent is ambiguous and the distinction would expose the answer, ask one short question before generating it.
    
    Build a single HTML file with inline CSS, JavaScript, and SVG or Canvas as useful. Start from the bundled [visualization shell](assets/visualization-shell.html), copying only what the artifact needs so the final file remains standalone. Use English interface copy by default; honor an explicitly requested language. Keep one dominant visualization in the shell's glass language: the figure fills the stage, controls float over it as frosted panels, text stays neutral, and the Ember accent (amber → coral) marks only the current value or state. Keep the shell's type scale and a light/dark toggle aligned with the title. Remove default branding, sibling navigation, numbered kickers, repeated instructions, draft badges, and unrelated commentary from the learning surface. Repository documentation carries draft and review status.
    
    Place actions beside the object they change, with graph playback directly below its graph and readouts beneath it. An input should produce an immediate visible effect within the permitted hint scope. Separate interpretation from controls in a clear feedback area. Keep calculations and relevant model assumptions available on demand; a boilerplate limitations section is not required. Use an isometric or 3D view when spatial relationships help explain the mechanism, optionally paired with a precise 2D chart. When the gap is about how something is built, use the [exploded view](references/exploded-view.md). A clear observation should lead back to the learner's explanation.
    
    Reuse the shell's comparison-row, annotated-item, and reference-task patterns and the adapter's alignment rules. Keep task context, question, and actions together; center shorter reference content within its panel. Showcases and newly requested visualizations share these assets; avoid undocumented scene-specific polish.
    
    Compose desktop examples for one visible frame, targeting 1280×720 with the main visualization, controls, and current result available without scrolling. Reflow or simplify before reducing type; preserve readable labels and never crop content or scale the page to fake a fit. Mobile and expanded reference details may scroll.
    
    For existing work, a plot can also expose an implausible result. Separate what the figure visibly establishes from what still needs evidence. Agreement between a model and its own drawing is not independent confirmation.
    
    **Automated tests are forbidden for work performed by this skill.** Do not write or run unit tests, snapshot tests, browser test suites, coverage jobs, or benchmark suites. Do not import test requirements from another skill or the source Argmin workflow. Use direct inspection of the model and a manual browser look at the file and its controls when available. Describe only checks actually performed. If a mandatory host rule conflicts, explain the conflict and keep tutoring in chat while resolving file work with the learner.
    
    Return a clickable file link and one short explanation of what to explore. Wait for the learner's prediction or revised explanation. Do not append the solution to a hint artifact's delivery message.
    
    When the learner gives visual feedback, update the reusable adapter or shell when the lesson applies across topics, then apply it to the current artifact. Record GIFs or other promotional demonstrations only after the owner explicitly approves the HTML being recorded. Approval of one draft does not approve another or authorize publication.
    
    ## Establish completion
    
    Assess the learner against the agreed target. Mark it complete when their own explanation is correct at that scope, the essential reasoning is present, and the misconceptions surfaced during the session have been resolved. If memorized wording could conceal the gap, ask one small new example, prediction, or application before concluding. This is a learning activity, not a software test.
    
    Explain briefly what they demonstrated. Separate an outstanding gap or an unverifiable claim from a completed target. One completed topic does not imply mastery of the whole field. A pause or a decision to stop is a valid session ending without a completion claim.
    
    When the learner wants to resume later, offer a compact handoff containing the target, source locators, demonstrated understanding, unresolved gap, assistance already revealed, and the next question. Save it only in the agreed location. Keep source text, full transcripts, and solution keys out of the handoff. On resume, read this small handoff rather than replaying every artifact.
    
    For provenance and the distinction between the video's methods and this skill's design additions, see [sources.md](references/sources.md). Label authored promotional conversations as illustrative. Permission to record or publish comes from the owner's current instructions, not the existence of an example.
    
  • examples/README.md3.3 KB405ce2527539upstream ↗
    # Learning visualizations
    
    Open a file directly in a browser; no installation, server, CDN, or framework is needed. Each example has an English interface, light/dark themes, and a compact desktop layout targeting 1280×720. Mobile views and opened reference notes may scroll.
    
    | Example | Explore | Scope |
    | --- | --- | --- |
    | [Gradient descent](gradient-descent.html) | Change the learning rate, inspect the next-step preview, then run, pause, or advance the trajectory. | Exact one-dimensional quadratic, fixed positive learning rate, no noise. |
    | [Spanish word order](spanish-word-order.html) | Compare English and Spanish sentence tiles and predict the position of a color adjective. | Neutral color-adjective placement in the selected example, not a rule for every Spanish adjective. |
    | [Process bottlenecks](bottleneck.html) | Change station capacities in an isometric chain and compare capacity with output in the accompanying chart. | Deterministic serial production with sufficient material, demand, and buffers. |
    | [MacBook Pro](macbook-pro.html) | Exploded view of the 14-inch MacBook Pro with PROLED XDR Display: the lid's layer stack (glass, tandem OLED with built-in touch sensor, camera, lid) and the base. Export a labelled PNG or SVG. | Apple's published specs, announced 28 October 2026; proportions illustrative, items marked reported come from press coverage. |
    | [Key switch](keyboard-switch.html) | Exploded view, vertical: descend from above to eye level, turn and tilt, open each of the eight parts. | Typical linear switch; dimensions and forces are typical values. |
    | [Limo door](limo-door.html) | Exploded view, horizontal through the door's thickness; armour and five-ply window. | Public reporting only; layer split and thicknesses are illustrative. |
    | [Flashlight](flashlight.html) | Exploded view, horizontal along the beam. | Generic two-cell AA flashlight; typical values. |
    | [Studio Display XDR](studio-display-xdr.html) | Exploded view, horizontal from glass to back. | Apple specs; generic mini-LED layers marked typical. |
    
    These are full-explanation showcases. A hint artifact would contain only the current hint, including in its source. They are not recordings of real tutoring sessions or evidence of learning effectiveness.
    
    ## Shared patterns
    
    The examples use the [shared shell](../assets/visualization-shell.html): a consistent header, type scale, and task grouping. The capacity chart uses its comparison-row pattern; the language example uses its annotated-item pattern. The skill has these same components available for new requests.
    
    ## Request the same learning scope
    
    After starting the skill, ask for one of these scopes. Generated copy and composition may vary.
    
    ```text
    Create a full-explanation HTML exploration of
    gradient descent on f(x) = (x - 3)^2 with live learning-rate feedback.
    ```
    
    ```text
    Create a full-explanation HTML comparison of
    English and Spanish color-adjective placement using sentence tiles.
    ```
    
    ```text
    Create a full-explanation HTML exploration of
    a three-stage production bottleneck, with an isometric line and capacity chart.
    ```
    
    The main README includes rendered GIF previews of all three models and an illustrative learning conversation. They are authored previews, not browser recordings. Rendering sources and frames stay outside this repository.
    
  • README.md5.5 KB19cb1462034bupstream ↗
    # Socratic Workshop
    
    By [Noa Katana](https://noakatana.com/work/socratic-workshop/), creative technologist in Munich.
    
    Learn an idea by explaining it to your AI tutor. It works for any subject: math and machine learning, a new language, or an unfamiliar codebase.
    
    The tutor asks one question at a time and gives a small hint when you get stuck. You work through the gap and explain it again. Bring your own book, course, paper, or codebase.
    
    When a picture helps, ask for a compact interactive HTML visualization. Explore it, make a prediction, and explain what changed.
    
    Directly inspired by **Miles Cranmer's [How to Avoid AI Brain Rot](https://www.youtube.com/watch?v=uXC7OuCas2Q&t=1438)**, especially 23:58–34:33. The visual approach uses my Workbench adapter, inspired by **[Anatomy](https://github.com/wheresryan22/anatomy)**.
    
    ## Start a session
    
    Install with the [skills CLI](https://github.com/vercel-labs/skills), then choose your agent:
    
    ```sh
    npx skills add smashburger-dev/socratic-workshop
    ```
    
    Add `-g` to install for your user instead of one project.
    
    | Agent | Start learning |
    | --- | --- |
    | [Claude Code](https://code.claude.com/docs/en/skills) | `/socratic-workshop Help me understand L2 regularization. Let me explain first.` |
    | [Codex](https://developers.openai.com/codex/skills/) | `$socratic-workshop Help me understand L2 regularization. Let me explain first.` |
    
    Claude Code uses `/skill-name`. Codex uses a `$skill-name` mention or its `/skills` picker. You can also ask your agent to use the skill in plain language.
    
    ## The learning loop
    
    ![The learning loop: explain, find a gap, request a hint, revise, apply.](media/learning-loop.jpg)
    
    Explain what you understand. Work through one question or requested hint. Revise your explanation, then apply the idea to a small new case. Finish when your own reasoning establishes the goal you chose.
    
    ![An illustrative L2 regularization learning session.](media/learning-loop.gif)
    
    An illustrative conversation about a Gaussian prior and L2 regularization, rendered for this demo. It is not a recording of a real learner.
    
    ## Visual learning
    
    ### Gradient descent
    
    ![Gradient descent: change the learning rate and follow the next step.](media/gradient-descent.gif)
    
    [HTML file](examples/gradient-descent.html)
    
    ### Spanish word order
    
    ![Spanish word order: compare the position of a color adjective.](media/spanish-word-order.gif)
    
    [HTML file](examples/spanish-word-order.html)
    
    ### Process bottlenecks
    
    ![Process bottlenecks: see how one station limits a production line.](media/bottleneck.gif)
    
    [HTML file](examples/bottleneck.html)
    
    ### How is it built? Exploded views
    
    Ask how something is assembled, and the tutor can build an exploded view:
    
    ```text
    /socratic-workshop How is the new MacBook Pro built? Show me the parts, then let me explain why its screen can sense touch.
    ```
    
    ![Exploded view of the MacBook Pro with PROLED XDR Display: open the panel to read how Touch is built in.](media/macbook-pro.gif)
    
    Scroll to descend from a bird's-eye view to eye level, drag to turn and tilt, and click a part to read its job and its real specifications. Up and Down walk the parts in assembly order. When you stop, the object keeps turning slowly from wherever you left it. Parts can separate vertically, horizontally, radially, or each in its own direction. Export saves the current view as a print-ready PNG or SVG with part labels.
    
    [MacBook Pro](examples/macbook-pro.html) · [Key switch](examples/keyboard-switch.html) (vertical) · [Limo door](examples/limo-door.html) · [Flashlight](examples/flashlight.html) · [Studio Display XDR](examples/studio-display-xdr.html) (horizontal)
    
    These GIFs are rendered previews of the example models. The illustrative prompt above was written for this demo.
    
    Download an HTML file and open it in a browser. Each is standalone, with light/dark themes and no build step. GitHub's file view shows the source.
    
    The same [visual templates](assets/visualization-shell.html) are available to the skill. A hint view reveals only the current hint; a full explanation can support direct exploration. Desktop examples are composed for a single visible frame.
    
    You can ask for a hint, a visualization, a direct explanation, or a pause at any point. Study material stays outside the tutoring chat. In a codebase, the tutor offers a worktree, a branch, or read-only study before creating learning files. It creates no automated tests for those artifacts.
    
    ## Make it yours
    
    Use this skill as a starting point. Adjust the visual style, change how hints work, or extend the learning loop to suit how you learn. Edit [SKILL.md](SKILL.md) and the [visual guidelines](references/workbench.md), or ask your agent to help.
    
    ## Credits
    
    - [Miles Cranmer's talk](https://www.youtube.com/watch?v=uXC7OuCas2Q&t=1438), shared by MPhil in Data Intensive Science Cambridge, inspired the learning workflow.
    - [Anatomy](https://github.com/wheresryan22/anatomy) inspired the visual approach and the exploded views, adapted from my Werkbankfiguren work in [Argmin](https://github.com/smashburger-dev/argmin). The exploded views and their PNG/SVG export are inspired by Jakub Krehel's [/teardown skill](https://github.com/jakubkrehel/skills/tree/main/skills/teardown); the kit here is an independent implementation.
    - The frosted-glass visual language comes from my chiasma design system, with material and legibility guidance from Apple's [Human Interface Guidelines](https://developer.apple.com/design/human-interface-guidelines/materials).
    - [Source notes](references/sources.md) separate the talk's ideas from this skill's additions.
    
    ## License
    
    [MIT](LICENSE).
    
  • references/codebase-learning.md2.5 KB63ecf0056951upstream ↗
    # Learning from an existing project
    
    Use a project to find a concrete learning question. The learner may want to understand code they wrote months ago, inherited code, or work produced by an agent. Familiarity with the repository does not establish understanding of its mechanisms.
    
    ## Choose a slice
    
    Ask what they find unclear. If they want suggestions, follow the environment's required discovery order. Use an available project knowledge graph first where required, symbol tools next, then narrow source reads. These are optional capabilities of the host, not dependencies of this skill. When none are available, inspect a bounded entry point and its immediate calls.
    
    Offer a few targets tied to actual files or symbols and the idea each teaches. Examples might be tracing one request, explaining an invariant, understanding a data transformation, or comparing an implementation with its algorithm. These examples are possible targets, not claims about an uninspected repository.
    
    Agree on one target. Use exact file/symbol locators and the current checkout as the source of truth. Check whether documentation describes another revision before grading against it. Expand context only when a missing relationship blocks the learner's explanation.
    
    ## Preserve the learner's work
    
    Before file creation in an existing Git project, offer a separate worktree, a separate branch, or read-only study. Explain that a branch uses the current checkout while a worktree provides another directory. Respect their choice and existing authorization. Read-only discussion can start immediately.
    
    Keep notes and HTML in the agreed learning location. A small standalone artifact should not require changes to package manifests, production source, or a build pipeline. Commits, pushes, and sharing are separate actions.
    
    ## Facilitate
    
    Ask the learner to predict behavior or trace a small concrete input. They should explain why one step follows another. When their mental model differs from the implementation, use a locator as a hint so they can inspect it themselves. Cite the relevant source when establishing the final correction, without pasting the surrounding module.
    
    Separate these questions:
    
    - What does this checkout do?
    - What is the intended behavior?
    - Is that behavior correct for the stated requirement?
    
    A source file can establish the first and still be wrong about the other two. Use a manually traced example or a requested visualization when useful. Continue to obey the skill's prohibition on automated tests. A discovered production bug can be noted for a separate, explicitly requested fix.
    
  • references/exploded-view.md15 KBaf6fef55a287upstream ↗
    # Exploded view
    
    Read this when the learner's gap is about structure: what something is made of, in which order, and why each part is there. The object is pulled apart along the axis it was assembled on, so the order of the parts is the explanation. Every part has a job; a part without one is cut.
    
    This is a Workbench mode. Everything in [workbench.md](workbench.md) applies: the learning boundary, glass, motion, spacing and delivery. This file adds only what is specific to exploded views. The kit in [exploded-view-kit.js](../assets/exploded-view-kit.js) implements the camera, the renderer, picking and the part popover; copy it inline into the output so the file stays standalone. Start a new exploded view from [keyboard-switch.html](../examples/keyboard-switch.html): keep its `<head>` styles and the inlined kit unchanged, and replace only the title, intro and the parts script at the end. [keyboard-switch.html](../examples/keyboard-switch.html) (vertical stack), [limo-door.html](../examples/limo-door.html) (horizontal, through the door's thickness) and [macbook-pro.html](../examples/macbook-pro.html) (mixed: a tilted lid stack and a vertical base, per-part offsets) are the reference examples. The docked toolbar, popover, spacing and motion follow every Workbench guardrail; this mode has no exceptions. The keyboard legend sits in the header area in the upper third, not under the toolbar.
    
    ## Plan it
    
    1. **Truth table first.** Before any geometry, write the parts as data: name, one-sentence job, real dimensions and the one or two numbers a learner would ask about (travel, force, thickness, capacity). Use typical values from a datasheet or standard and say "typical" where they vary. The geometry, the popover and the readout all read this table.
    2. **Pick the assembly axis.** Parts move apart the way they were put together: `vertical` for stacks (a key switch, a phone, a PCB), `horizontal` for things assembled side by side or layered through their thickness (a flashlight, a drivetrain, an armoured door, the layers of a display), `radial` for things built around a centre (a motor, layers of a cable), or a per-part vector when the real disassembly is mixed. The axis is a choice about meaning, not about fitting the frame.
    3. **Explode far enough to see into every part.** In the exploded state the clear gap between two neighbours along the axis is 0.6 × the larger of their footprints (the width across the axis), so from any elevation on the L-curve down to about 30° you can see the top of the lower part and the underside of the upper one (a stem's cross, a socket, a spring seat). Compute offsets cumulatively from each part's real extent, not from a fixed share of the total height. Plates (thinner along the axis than a quarter of their smaller face side) are the exception: in a stack where most parts are plates, the gap next to a plate is 0.2 × the plate's smaller face side, so a stack of large panels opens at 45° without stretching into a corridor.
    4. **5 to 12 parts.** Fewer and nothing is learned; more and the learner stops reading. Merge screws and clips into the part they hold unless the fastener is the lesson.
    5. **Order is reading order.** Parts are listed in assembly order. Up and Down in the popover walk that order.
    
    ## Draw it
    
    - Build parts from the kit's primitives (box, rounded box, cylinder, frustum, ring, helix, extruded convex polygon) placed in millimetres, in real proportions. Small true details (a spring's turns, a stem's cross, pins) carry more than surface decoration.
    - Parts read as drawn objects: flat-ish shading plus thin crease lines on every edge sharper than 30°, so a grey box never dissolves into a grey blob.
    - The object always fills the view and is never cut off: fit the camera to the assembly's swept envelope (its projected bounds sampled over a full turn at the current elevation and explode amount), so it fills about 60 % of the free height in the overview, sits centred in the free space by its screen bounds rather than its 3D centre, and does not breathe while it spins. The L-curve scales that fitted distance instead of using fixed units.
    - No coplanar faces and no z-fighting: holes, discs and decals are real geometry offset at least 0.05 mm from the surface they sit on, and an opaque layer that must hide a detailed layer behind it (a cover glass over a touch grid) sits at least 0.5 mm in front of it, drawn with polygon offset, and the near/far ratio stays at or below 1 : 1000. Check by scrolling slowly through the whole L-curve with the part closest to a surface open.
    - Every part keeps its contrast in both themes: its lightness differs from the ground by at least 0.15 (OKLab L). The kit maps the material tiers per theme (dark theme L' = 0.38 + (L − 0.30) · 0.93, light theme L' = 0.22 + (L − 0.30) · 0.97), so a dark keycap is mid-dark grey on the dark ground and a clear sleeve is mid-light grey on the light ground.
    - Stacks of plates (layers that are thin along the explode axis: armour, glass laminates, display layers) start with the explode axis at about 45° to the view direction (default yaw ±45°), so every plate shows its face and the gaps between plates are visible. Never start a plate stack edge-on.
    - Long horizontal rows (length more than twice their other extents) start with the row near screen-horizontal (default yaw −15°, compact objects −35°) and are fitted to their bounds at that default yaw, so they use the screen's width; while turning, their ends may pass under the docked bars. Compact objects are fitted to their yaw-swept envelope so their size does not change while turning.
    - **The scene is a seamless studio cove.** Floor and background are one colour, the page ground, with no edge anywhere: no finite floor disc, no horizon line, no gradient that ends. In light theme that ground is near white (`#fafafa`, L 0.985), in dark theme the usual dark ground. The only things that mark the floor are the plinth and the contact shadow, so at every elevation and zoom the object stands in a finished space. The camera never goes below the plinth top (eye height ≥ plinth top + 2 % of the camera distance), so nothing is ever seen from underneath.
    - The object stands on a visible plinth: always a true circle, never an ellipse or a shape stretched to the object's footprint. It is centred on the turn axis under the lowest part, with radius r = max(0.4 × the largest dimension of the exploded assembly's bounding box, 1.1 × the largest horizontal distance of any part from the axis); long rows use 0.35 × their length instead and let the exploded ends overhang. Its size never changes while turning or tilting. It is a low cylinder (height 0.02 × r, at least 4 mm) drawn in flat, unlit colours, because lighting turns a light plinth grey: top ground L + 0.06 in dark and − 0.045 in light, side band + 0.025 / − 0.09, a crease line on its top edge and the contact shadow of the lowest part on it. Read the ground's L as the cube root of its luminance (the exact OKLab L of a neutral grey), never from an approximation. Check it in a screenshot of both themes: the plinth top must differ from the surrounding floor by at least 0.05 L. An object floating with no floor or plinth is a defect.
    - Spatial order equals list order. Along the explode direction, part n+1 sits next to part n, so Up and Down always move the camera to a neighbour, never across the whole object. Choose the order so parts of similar shape are not adjacent where an alternative reading order is equally true.
    - **It looks like the thing that was asked for.** Someone who knows the object recognises the assembled model at a glance from its silhouette and its signature features: a monitor has its stand and the logo on its back, a car door has its window frame, handle and emblem, a keycap has its sculpted, tapered profile. Build the outline from the real shape (convex extrusions, rounded corners, slanted edges), not from a box with the right size. Give each part its one or two telling details (holes, slots, ribs, a logo, a hinge) and stop there: details that identify, not decoration.
    - **Neighbours never look alike.** Two parts next to each other must differ by more than thickness: a different lightness tier, a different finish (gloss or matte), or a structural feature that says what the part is. Prefer the real structure: armour ceramic as a grid of tiles, dual-hardness steel as two sub-layers, laminated glass with its thin interlayer films, optical films as a fanned stack of separate sheets, an LCD with its driver flex cables along one edge, a circuit board with chips and connectors, a speaker with its cones. Check it in the exploded state: cover the labels and every part must still be told apart from its neighbours.
    - **Assembled means assembled.** In the assembled state the outer parts close the object the way the product does: an enclosure or frame wraps the stack, so no inner layer shows at the edges, and a front glass is dark and glossy with its printed border, not a light slab that shows the layers behind it.
    - Parts render double-sided: back-face culling stays off and the shader turns every normal toward the camera, so one wrongly wound triangle can never open a see-through hole. This is the kit's job, not each example's.
    - Every part is a closed solid. A tube has an outer wall, an inner wall and two end rings; a cone or reflector has a real wall thickness or end caps; nothing is a single open surface, so the crease lines and the SVG export stay clean. Check every part from front, back, both ends, above and below before shipping.
    - The assembled state must look like the real object: parts nest where they really sit (cells inside the tube, lens inside the bezel, glass inside its frame), nothing pokes through a wall, and outer parts hide inner ones. Check the assembled state from the same six views.
    - Materials are neutral lightness tiers, not colours: dark plastic, light plastic, metal, board. The open part takes the Ember gradient (amber at its top, coral at its base); every other part stays neutral. No text inside the 3D scene.
    - The stage is the plain Workbench ground; the canvas draws only the plinth and the contact shadow over it.
    - **Model in local frames.** A hinged or tilted sub-assembly (a laptop lid, a door on its hinge) is modelled upright in its own frame with the hinge at the origin, then placed with one helper that applies the same rotation to every primitive's position and orientation. Never rotate primitives one by one by hand. `GEOM.box(w, h, d)` is x × y × z; write the axis next to every size in the truth table so a 150 mm long speaker never becomes a 150 mm tall pillar.
    - **Finish follows the product.** The surface finish says what the text says: a nano-texture or matte option renders matte (low spec), polished glass and logos glossy, anodised aluminium satin. If the popover mentions a finish, the material shows it.
    
    ## Interaction (the kit implements these; keep them)
    
    - **The L-curve.** Scroll or pinch moves the camera along one L-shaped path: a vertical leg that descends from a bird's-eye view (elevation about 69°) to eye level (about 5°), a rounded corner, then a horizontal leg that moves in at eye level. Scrolling out runs the path back up. Each leg gets a fixed share of the scroll (descent 45 %, corner 15 %, approach 40 %) and is uniform by arc length inside it, so the close-up is not squeezed into the last few ticks.
    - **Turn and tilt.** Left-drag sideways turns the object around its own vertical axis, with a little inertia; it never bobs up or down while turning, because the view is centred on a turn-invariant point. Dragging up and down tilts the view (elevation offset, clamped to 2°–85°) on top of the L-curve. Arrow keys left and right turn; up and down tilt while no part is open. Reset view clears the tilt.
    - **Idle spin, always.** After 3 s without input the object turns slowly on its own axis (8°/s, eased in over a second), at whatever elevation, zoom, tilt and explode state the learner left it: from above, at eye level, close up, assembled or exploded. It continues from the current yaw, never snaps back to a default. Any input stops it; it resumes after the next 3 s of quiet. It pauses only while a part's popover is open, so the text and its leader line hold still, and reduced motion disables it.
    - **Parts.** Hover lifts a part's lightness. Click opens its glass popover beside it: name, position (3 / 8), the job sentence, its numbers. The popover goes to the side of the open part that is free of the other parts: left or right of a vertical stack, above or below a horizontal row. It never covers another part of the object; check this with the projected bounds of all parts, not only the open one. Up and Down walk to the neighbouring part; Close, Esc or a click on empty space returns to the whole. The camera target eases to the open part, and it eases again when Up, Down or a click switches straight from one open part to another.
    - **Assembled and exploded.** A segmented control in the docked toolbar (and the key E) moves the parts together or apart. Views open exploded.
    - **Keyboard and screen readers.** Every action has a key and a button. The kit keeps a hidden ordered list of parts as buttons and announces the open part in a live region.
    
    - **Export.** The toolbar's Export button saves the current view print-ready: always light colours on white, no plinth or shadow, cropped to the object, its labels and the title with a 48 px margin. In the exploded state every part gets its name in two label columns outside the object, with leader lines to the part. PNG at 4×. SVG is true vector: a GPU visibility pass (triangle ids) drops every fully hidden triangle, a BSP tree orders the rest back to front (plain depth sorting shreds layers 1 mm apart), crease lines are kept only where they are visible, and text stays text.
    
    ## Learning boundary
    
    In a hint artifact, only parts the learner has already established carry their job and numbers. The others show as "Part 4" with no description in the HTML, the data or the accessible names. Opening a part does not unlock the next hint.
    
    ## Inspect
    
    Look at the file in a browser: bird's-eye, the corner, eye level close up, one open popover, light and dark, reduced motion, a narrow viewport. Repeat the framing and popover checks at landscape (1280 × 720, 1920 × 1080), near-square (870 × 900) and portrait (390 × 844) windows, and walk every part with Up and Down down to the lowest one: each open part must sit fully inside the free area with its popover beside it. Check that the parts' order and numbers match the truth table. For a quick all-round check, capture contact sheets of four turns (0°, 90°, 180°, 270°) at bird's-eye and eye level, assembled and exploded, in both themes, and export one PNG and one SVG of the exploded view and compare them side by side.
    
    ## Record it
    
    README previews and posts come from the real file: capture with the browser's screencast (every rendered frame with its timestamp), resample to a constant 30 fps (24 fps if the GIF would pass 8 MB), and encode at 960 px wide with a per-video palette. Start from a three-quarter view where the main face shows (a screen faces the camera, a door shows its outside), hold still long enough for the idle spin to start, open the part that carries the lesson for about three seconds, then show assembled and exploded once each.
    
  • references/sources.md5.0 KB61c26e7d0567upstream ↗
    # Sources and design provenance
    
    ## Video
    
    Miles Cranmer, [How to Avoid AI Brain Rot](https://www.youtube.com/watch?v=uXC7OuCas2Q&t=1438), uploaded by [MPhil in Data Intensive Science Cambridge](https://www.youtube.com/@MPhilDISCambridge), 16 October 2026. Requested segment: **23:58 through 34:33**.
    
    The design was informed by YouTube's timestamped English automatic captions, retrieved on 17 October 2026 using the already available `yt-dlp` metadata client and YouTube timedtext. No full video download was needed. The chapter boundaries below are derived from those captions; they are not official chapter labels. Automatic transcription can contain errors. Slides and on-screen demonstrations were not independently inspected.
    
    | Interval | Source-grounded design input |
    | --- | --- |
    | [24:00–24:59](https://www.youtube.com/watch?v=uXC7OuCas2Q&t=1440) | The learner explains; the AI asks questions; gaps lead to hints, reading, and another attempt. |
    | [25:00–29:10](https://www.youtube.com/watch?v=uXC7OuCas2Q&t=1500) | Ground tutoring in books and papers; recognize limitations around niche subjects and new research. |
    | [29:11–31:11](https://www.youtube.com/watch?v=uXC7OuCas2Q&t=1751) | A worked discussion of L2 regularization and Gaussian priors uses one question at a time, withheld answers, and requested hints. |
    | [31:12–32:34](https://www.youtube.com/watch?v=uXC7OuCas2Q&t=1872) | Interactive concept demonstrations, including the learning rate in gradient descent; generated demos can be wrong. |
    | [32:35–34:33](https://www.youtube.com/watch?v=uXC7OuCas2Q&t=1955) | Visual inspection can expose implausible agent results. A fitted trajectory crosses a floor despite apparently fitting motion measurements. |
    
    This repository paraphrases the methods and links to the source. It does not redistribute the transcript, slides, or video. The video is inspiration, not an endorsement of this skill or evidence of its learning effectiveness.
    
    ## Noa's design brief
    
    The project owner specified learner-led explanations, requested hints, external study material, retrospective project learning, standalone HTML, a portable Workbench visualization adapter, no automated tests, and private development until approved examples and recordings exist. The private voice-note text is not bundled with the repository.
    
    The hint ladder, small session handoff, completion criteria, optional prediction/application, spoiler boundaries inside HTML source, and illustrative promotional scenes are this skill's design choices. They should not be attributed to Cranmer as claims made in this segment.
    
    The owner's UI feedback on 17 October 2026 added English presentation, quieter layouts, larger type, light/dark controls, immediate visual feedback, co-located actions, and optional spatial views. Those preferences are implemented in the portable adapter and copyable shell. The Spanish example replaces the initial German example. GIF capture follows approval of the HTML.
    
    ## Workbench
    
    The bundled [portable adapter](workbench.md) credits its Argmin source and records which principles were adapted. It carries the visual approach without Argmin's project structure or automated-test workflow. The adapter is not a claim that the original skill already generalized to every subject.
    
    The owner also identified [Anatomy by wheresryan22](https://github.com/wheresryan22/anatomy) as visual inspiration. Its upstream repository and MIT license were checked on 17 October 2026. This version credits the approach without bundling Anatomy code or making it a dependency.
    
    The exploded-view mode was inspired by Jakub Krehel's [/teardown skill](https://github.com/jakubkrehel/skills/tree/main/skills/teardown) ([announcement](https://x.com/jakubkrehel/status/2114379959263502712), 25 October 2026; repository MIT-licensed, checked 28 October 2026). His skill draws exportable technical illustrations of an object's parts. This mode is an independent implementation with a different goal: a learner walks an assembly in 3D (L-curve camera, turn and tilt, part popovers with real specifications). No code from his repository is bundled.
    
    ## Packaging
    
    The folder layout and frontmatter follow the [Agent Skills specification](https://agentskills.io/specification), consulted on 17 October 2026. Product-specific UI metadata is kept in `agents/openai.yaml`; the learning workflow does not depend on it.
    
    Installation commands follow the [skills CLI](https://github.com/vercel-labs/skills). Invocation syntax follows the official [Codex skills documentation](https://developers.openai.com/codex/skills/) and [Claude Code skills documentation](https://code.claude.com/docs/en/skills), checked on 17 October 2026. The [MIT license text](https://opensource.org/license/mit) replaces the private-development notice at the owner's request.
    
    ## Browser APIs
    
    The theme implementation follows the system preference described by [MDN's prefers-color-scheme reference](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme), with a user override. This implementation reference was consulted on 17 October 2026.
    
  • references/workbench.md27 KB1b1a4cc2934dupstream ↗
    # Workbench for Socratic Workshop
    
    Read this reference when an interactive figure can address the current understanding gap. Choose a controllable cause and an observable effect. If interaction adds little, a small static diagram is enough.
    
    ## Origin and portable assets
    
    Adapted from the Werkbankfiguren work in [Argmin](https://github.com/smashburger-dev/argmin). Retained principles are a visible mechanism, model-derived geometry and numbers, meaningful motion, accessible controls, and explicit limits where an analogy could mislead. The original Argmin scene registry, renderer, test workflow, and warm palette are not required here.
    
    The visual approach is also inspired by [Anatomy](https://github.com/wheresryan22/anatomy), an open-source skill for interactive explanations. This adapter is standalone; Anatomy is an inspiration rather than a runtime dependency.
    
    Use [visualization-shell.html](../assets/visualization-shell.html) as a copyable starting point for layout, theme colors, typography, controls, and theme switching. Copy the relevant parts into one HTML file with inline CSS, JavaScript, and SVG or Canvas. Trim unused styles. The output works directly from disk with system fonts and no network, package installation, CDN, or build step.
    
    Copy its comparison-row, annotated-item, or reference-task pattern when applicable. The reference-task wrapper stretches both panels so a shorter reference can center beside the task. The showcase examples use these same patterns; apply general refinements here before adapting a particular scene.
    
    ## Preserve the learning boundary
    
    The main skill determines the permitted scope:
    
    | Mode | Information in the artifact | Interaction |
    | --- | --- | --- |
    | Hint | Only the current hint and already established information | Explore an observation or a smaller subproblem, then return to the conversation |
    | Full explanation | The requested mechanism and explanation | Explore directly or predict and reveal, then explain the observation |
    
    A hint file contains no later solution in its HTML, SVG, JavaScript, data, comments, accessible names, or computed states. Hiding content with CSS or a disabled button does not preserve this boundary. Keep sliders and previews within the permitted scope. A prediction or click cannot authorize another hint level. Add a new level only when the learner requests it.
    
    Prediction is useful when comparing expectation with an observation. It is not a mandatory gate on every slider or every figure. For a full exploration, show the effect of changing a value immediately. In a prediction activity, keep the learner's choice visible beside a separately presented outcome. Grade only a bounded factual choice; leave open explanations for discussion rather than matching a string.
    
    ## Make the mechanism visible
    
    Keep a small model containing inputs and derived quantities. Graph coordinates, quantitative geometry, numerical labels, and displayed calculations use that same model. Fixed layout spacing is fine; independently typed copies of scientific values are not. For language or other qualitative topics, use explicit cases rather than invented numerical measurements.
    
    Choose the representation for the question:
    
    - A 2D curve can make direction and step size easier to read than a perspective surface.
    - An isometric process can distinguish stages, connections, and flow. Pair it with a common-scale capacity chart when the comparison matters.
    - A 3D view can explain a spatial mechanism. Use SVG projection or a small Canvas renderer when sufficient; importing a 3D framework is not a default requirement. Provide view controls only when changing viewpoint helps the learner.
    - Sentence tiles can make constituent movement visible while keeping the complete example readable.
    - An exploded view answers "what is this made of and in which order": the object comes apart along its assembly axis, and each part explains itself on click. Read [exploded-view.md](exploded-view.md).
    
    These are examples, not a fixed subject catalog. Apply the same cause-and-effect reasoning to science, mathematics, language, code, planning, or business. Every visible object should carry a meaning or a control.
    
    Use crisp vector geometry and legible HTML labels where possible. Label axes, units, and scale. Keep the scale stable during a comparison or playback so rescaling cannot disguise growth. Fix the axes for the whole range of every control, not for its current value: dragging an input moves the mark across a still chart and never rescales it. If a value leaves the view, show that fact and the actual value rather than clamping it silently. A second chart should answer another necessary question, not decorate the first.
    
    ## Keep the interface quiet
    
    The default surface contains a short title, at most one useful introductory sentence, the visualization, its controls, and its current result. Use English for shared examples and default interface copy; honor the learner's explicit language choice. The subject's actual language remains unchanged in a language-learning example.
    
    Respect the system preference initially and provide a visible toggle. Keep essential labels readable in both themes. Saving the theme is optional and must tolerate storage being unavailable. Do not persist learner answers without a request.
    
    ### Glass
    
    The visual language is Noa's `design-glass`, adapted for learning. In one sentence: the mechanism fills the screen, every control floats over it as frosted glass with quiet neutral type, and colour appears only where a value or the current state lives. The tokens live in the shell; this section says how to use them.
    
    - **The work runs under the chrome.** The stage (the figure and its background field) spans the viewport. The pillar and the toolbar are docked over it; the header (title, intro and the keyboard legend in the upper third) sits directly on the work without a panel. Place the figure's plot area in the free space beside the panels, never under them, but let the stage background continue beneath them so the glass has something to blur.
    - **Glass for controls, never for content.** The pillar, the toolbar, popovers, tooltips and the theme switch are glass. Marks, tiles, curves and isometric parts are content: solid, never blurred, never translucent glass. (Apple HIG, Materials: "Don't use Liquid Glass in the content layer.")
    - **Chrome is docked, not floating.** Persistent chrome is fixed to the window edges, like chiasma: the control pillar runs the full height of the right edge, the toolbar runs the full width of the bottom edge (from the window's left edge to the pillar), both square-cornered, with one 1 px edge only on the side that faces the work. Groups inside them are divided by full-height (in bars) or full-width (in pillars) strong separators; soft separators inside a group stop at the inset. Only things that come and go are rounded floating glass: popovers, tooltips, notices, the theme pill. Buttons, fields and segmented controls inside the chrome keep their own radii.
    - **Docked chrome reflows, it never wraps into a mess.** Bars keep one row at every width: groups never wrap onto a second line; below the width that fits, the bar scrolls horizontally inside itself. Below 900 px the pillar moves under the figure as full-width, square-cornered glass sections divided by separators, and the toolbar stays docked to the bottom edge. Check 1280 × 720, 1600 × 900, 1920 × 1080 and 390 × 844 before calling a layout done.
    - **Glass is one recipe.** Tint at about half opacity, blur 6 px on docked chrome (4 px on popovers and pills), one 1 px light edge on the side facing the work, radius 0 on docked chrome and 16 on floating surfaces. No drop shadows, no gradient on the glass itself, no glass on glass.
    - **Neutral by default.** Text and lines are the text colour at fixed alpha tiers, never a grey hex: 1.00 titles and active items, 0.84 values, 0.68 body and rows, 0.60 labels, 0.56 hints and axis ticks (the lowest tier for anything meant to be read), 0.31 off states. Grid lines white 0.07, axes 0.20, neutral data marks 0.74. Hierarchy comes from alpha and one weight step (regular, semibold), never from extra colours.
    - **One accent, used as a gradient.** The Ember accent runs amber → coral. Its main use is the selection look (amber 0.15 → coral 0.06, edge amber 0.30) and the current value: the active mark, the slider fill, the moving part, the limiting bar. A second state of the same quantity (a preview, a prediction) uses coral as an outline. Everything else stays neutral. If a figure needs a third category, use a neutral tier and a shape cue before adding a hue.
    - **The work is a calm, plain ground.** The ground is flat and neutral (`--work`), fixed to the viewport so opening a panel never moves it. No dot grid, no texture, no glow, no spot: a pattern behind a figure competes with it. Colour on the work belongs to the figure's values and to the header intro. A 3D scene gets a world instead of a pattern (see the exploded view: a floor that runs to a horizon and a round plinth under the object).
    - **Marks explain themselves.** Every mark that carries meaning (the current point, a preview, a guide, a part) is a focusable button. Clicking it, or Enter, opens a small glass popover beside it: the name, one or two sentences, and its live value if it has one. Esc, a click outside, or a second click closes it. One popover at a time. The legend entries open the same popovers. A hint artifact explains only marks within the hint's scope.
    - **No visible gradient steps.** Any gradient wider than about 120 px interpolates in OKLab (`linear-gradient(in oklab, …)`) and carries a fine noise dither (a tiled inline SVG `feTurbulence`, 3–4 % opacity) so 8-bit banding never shows, in light mode especially. Check the slider fill and the stage floor at 2x zoom in both themes.
    - **Popovers sit beside, never on top.** A popover never covers the thing it explains. Place it 32 px from the mark's (or part's) screen bounds, trying right, left, above, below in that order, and take the first side where it fits entirely inside the free space without overlapping the mark. If no side fits (the mark fills the view), dock it to the nearest edge of the free space and keep it off the mark's visible area. A 1 px leader line (text 0.31) always joins the mark's nearest bound to the popover's nearest edge and is never shorter than 24 px; it updates every frame and never disappears while the popover is open. The side is chosen once, when the popover opens or its subject changes, and then stays locked: when the mark moves (spin, zoom, playback), the popover slides along its side with a short spring and, if that side runs out of room, docks to the free-space edge on the same side. It never flips sides while the same subject is open.
    - **Readouts share one size.** Numbers that sit side by side (step, x, loss) use the same size and weight; only their labels differ.
    - **Five text styles, nothing in between.** Type is Inter with system fallbacks, regular or semibold, never heavier. The ramp follows Apple's text styles at their large default size (HIG Typography: body 17 pt on iOS). Use only these, by role, so no element feels oversized next to its neighbours:
    
      | Style | Size / line | Weight | Roles |
      | --- | --- | --- | --- |
      | Title | 30 / 36 | semibold | page title |
      | Title 3 | 20 / 25 | semibold | section titles in the pillar |
      | Headline | 17 / 22 | semibold | feedback headline, popover title, part name |
      | Body | 17 / 22 | regular | control labels, slider values and toolbar readout values (tabular), disclosure rows, feedback text |
      | Subheadline | 15 / 20 | regular | button labels, bar status, readout labels, legend, axis ticks, popover text, hints |
    
      15 px is the floor for anything meant to be read. A number is one step above its own label and never larger than the text around it: toolbar readouts are Body 17 over Subheadline 15 labels.
    - **One spacing scale.** Every gap is a step of 4, 8, 12, 16, 24, 32 or 48 px; no other values. Stage padding 32. Title to figure 32. Pillar sections: padding 24, divided by full-width strong separators with no gap. Section title to first control 16. Label to its control 8, control to the next label 24. Toolbar: 64 high (10 around 44 px buttons), content inset 32 from its ends, 8 between buttons, 24 on each side of a full-height separator, 32 between readout columns; the action group sits at the start, the readout group at the end. Readout label sits 4 above its value. A single-line status in a bar ("Part 2 / 8") uses the button text style (Subheadline 15, tabular) and a reserved width, not a larger readout size.
    - **Rows centre their content optically.** A disclosure row (Try a prediction, See the calculation, Model notes) is exactly 52 px from its separator to the next separator (or to the panel's padding edge), with its label centred on cap height, not on the line box: use `text-box: trim-both cap alphabetic` where supported and an equivalent padding fallback. Measure it: the gap from the separator to the cap top equals the gap from the baseline to the next line, within 1 px. The chevron sits on the same optical centre at the panel's right padding. Opened content starts 8 below the row and ends 16 above the next separator.
    - **Fills never touch lines.** A hover, press or selection fill is its content box plus equal padding on every side (at least 8 horizontal, 4 vertical), with the content centred inside it. It never touches or covers a separator, a panel edge or a neighbouring fill; keep at least 4 px clear. Consecutive rows have no margins between them: the space between two separators belongs to exactly one row, split equally above and below its content. Measure separator to separator, not the element's own box, and check the hover state, not only the resting state.
    - **One button type everywhere.** Every button in every visualization, including the theme switch, is the same type: 44 px high, padding 0 16, radius 10, field fill and field edge at rest, Subheadline 15 label, an optional 18 px icon 8 px before the label, the shared hover/press/focus states. Primary or active = the selection look on that same shape. No pills, no one-off button styles.
    - **Choices of one state are a segmented control.** Two or more mutually exclusive states (Assembled / Exploded) form one control in the button type: one field-look track (r10), equal-width segments divided by a 1 px soft separator inset 10 px top and bottom. The track has no inner padding and clips its content (`overflow: hidden`). The active segment's whole area takes the selection gradient as a plain square fill; only the track's own outer radius rounds it at the ends. There is no inner pill, no inner radius and no inner edge. The gradient fill crossfades between segments in 200 ms. Actions that are not states (Above, Eye level) stay separate buttons.
    - **Toolbar controls use the room they have.** In a docked toolbar the action group fills the space up to the status group: each text control grows equally (`flex: 1 1 0`) from its content width up to 200 px (a segmented control counts as one unit per segment), and shrinks back to content width before the toolbar starts scrolling. Icon buttons never stretch; they stay 44 × 44.
    - **The header has one layout.** Title, then the intro 4 px below, then the keyboard legend 8 px below that, all sharing one left edge at the stage padding (check the glyph ink, not the boxes: the title's larger size must not sit visibly indented or outdented against the lines below). The theme button sits at the top right, its centre on the title's first line. Nothing else goes in the header. The intro line is set in the Ember gradient (amber to coral, `linear-gradient(90deg in oklab, …)` clipped to the text, weight 500); it is the one decorative use of the accent. Dark theme uses the theme's amber and coral; light theme uses darker stops (`oklch(0.55 0.15 60)` to `oklch(0.52 0.17 35)`) so the text keeps at least 4.5:1 against the ground. The title stays neutral.
    - **A figure that runs under the header gets a docked top bar.** When the figure fills the whole stage (3D scenes, exploded views), the header becomes a docked top bar in the same glass as the toolbar: full width, square, 1 px edge only at the bottom, padding 20 top and bottom, so the figure passes visibly under it instead of being cut off. In a docked top bar the theme button is centred vertically in the bar, not on the title line. When the figure sits beside the header (charts), the header stays on the work.
    - **Icons for familiar actions.** Reset view and similar universal actions are 44 px square icon buttons (a counter-clockwise arrow for reset) with an `aria-label` and a tooltip after 500 ms hover. The icon is 18 px, 1.7 px round-capped strokes, sized by `width`/`height` attributes and CSS both, because an unsized inline SVG grows to 300 × 150 and drags its button with it. The icon button is exactly as tall as its text neighbours. Use text where the action would be ambiguous as an icon.
    - **Reserve the size of anything that changes.** A box whose content changes while the learner interacts (readouts, Run/Pause, status lines, notices, popovers with live values) is sized for its longest state before the first interaction: tabular numerals, a fixed width in `ch` from the longest value the model can produce, the wider label for toggling buttons. Dragging a slider moves marks and digits, never the layout around them.
    - **Readouts are centred columns.** Each readout is one fixed-width column: label above, value centred under it, 32 px between columns, the same width for every column in a row.
    - **Everything clickable says so.** A learner who has never seen the page must find every control without instructions. At rest, controls look like controls: buttons have a field or selection fill, rows that open carry a chevron, marks have a visible shape and a pointer cursor. On hover, the whole hit area takes the hover fill (text 0.05) with the element's radius and the chevron rises to 0.84; on press 0.08; keyboard focus shows the amber ring. A disclosure row's hover fill spans the full row width, bleeding 8 px into the panel padding on both sides, radius 10, and stays 4 px clear of the separators above and below. Opening rotates the chevron 180° in 200 ms. Nothing clickable looks like plain text, and nothing that is plain text reacts to hover.
    - **Concentric corners.** When a control sits 12 px or less from its container's edge, the container's radius is the control's radius plus that padding (HIG: concentric corners). A segmented track with 2 px padding around r8 segments is r10. Other radii: 0 docked chrome, 16 popovers and floating notices, 10 buttons and fields, 8 tiles and inset groups, 2 chart bars.
    - **Marks are big enough to see at a glance.** The current mark is at least 14 px across; a preview or target mark is larger than the current one (ring 20 px across, 2.5 px stroke), so the eye finds where the change lands. An arrow stops 3 px before the mark it points at; it never runs into or under it. Hit areas stay 44 px.
    - **Accessibility settings win.** With `prefers-reduced-transparency`, glass becomes an opaque tint without blur. With `prefers-contrast: more`, edges rise to 0.40 and the 0.56/0.60 tiers to 0.80. With `prefers-reduced-motion`, values jump without travel.
    
    Size SVG text for its actual rendered width; shorten copy or reflow before shrinking it. Keep math tokens on one line (`x&nbsp;=&nbsp;3`, `η&nbsp;=&nbsp;0.25` with non-breaking spaces). Legend entries show the real mark shape next to their name. Use the accent for the current cause, state, or result, with a text or shape cue as well, so the figure still reads without colour.
    
    Co-locate controls with what they change. Graph playback and readouts live in the docked toolbar under the figure; the legend sits on the work directly under the graph. Reset stays inside the panel it resets. Put interpretation in a distinct feedback panel with a short headline and, if useful, one concise explanation. Avoid scattering a verdict, a calculation, and duplicate instructions across unrelated panels.
    
    For dialogue, keep the roles in separate, consistently positioned chat panels with names and distinct subdued colors. Hold an overview long enough to read before advancing; a brief transition is not a readable introduction.
    
    ### Alignment and space
    
    - Use the shell's shared header: title and theme toggle on one row, optional introduction below. Omit default branding and links to unrelated examples.
    - Group the task's context and any item to place on one aligned row; put its question, choices, and actions together below. On narrow screens, wrap whole groups in that order.
    - Center a shorter reference within its available panel when the adjacent task is taller. Keep panel headings on the same top line; do not leave the reference stranded at the top.
    - One datum, one row: label, mark, and value share layout tracks and a scale.
    - Metadata sits above the item in reserved space, outside its content surface.
    - Keep labels attached when wrapping; let content size the row instead of synchronizing separate columns with offsets or guessed heights.
    - Use one coherent set of layout rules. Replace obsolete overrides when changing the composition; do not stack compact fixes over earlier layouts.
    
    ### One frame on desktop
    
    Target 1280×720, with the mechanism, controls, and current result visible together, including after a reveal. Budget height before adding a panel. Use columns, shorter copy, and viewport-relative scene height before shrinking labels. Keep notes collapsed. Never hide overflow, zoom, or scale the page to manufacture a fit. Mobile and opened reference details may scroll.
    
    Remove numbered lesson kickers, repeated 'predict then reveal' labels, draft labels, and explanatory mini-paragraphs that repeat the visible control. Keep review status in repository documentation. Additional calculations can live in a 'Calculation' disclosure. Include model assumptions only where their absence could mislead, usually in a collapsed 'Model notes' disclosure. Explain a material analogy limitation near the relevant claim rather than adding a boilerplate footer to every figure.
    
    ## Make interaction immediate and controllable
    
    A slider must visibly change the mechanism, comparison, or an appropriate preview while it moves. Updating only its numeric label is insufficient. In hint mode, immediate feedback still respects the information boundary.
    
    For a temporal process, offer explicit Run/Pause, Step, and Reset controls when they help. Start motion only after a user action. Pause when inputs change, on reset, and at the end of a bounded sequence. Keep displayed state, active controls, and feedback synchronized. With reduced motion, use discrete updates without travel animations. A static diagram needs no playback bar.
    
    ### Motion
    
    Every change of state moves briefly and softly; nothing teleports, nothing lingers. Motion explains where a thing came from, it never decorates.
    
    - **Popovers and panels arrive.** A popover fades in while scaling from 0.96 and sliding 4 px from its anchor, 160 ms with `cubic-bezier(0.2, 0.8, 0.2, 1)`; it leaves in 120 ms ease-in. Disclosures open by animating their row height (`grid-template-rows: 0fr → 1fr`), 200 ms. Hover and press feedback 120 ms.
    - **The model stays discrete, the drawing glides.** Slider steps and computed values stay exact. The drawn value (slider fill and thumb, the mark on the chart, a bar's length) follows its target with a critically damped spring of about 120 ms, and a new input retargets the running motion instead of queuing another. Draw the slider thumb inside the track background at `--p` and register `--p` with `@property` so fill and thumb glide together while the native input keeps its keyboard and screen-reader behaviour. Numbers the learner reads change instantly.
    - **Steps travel the path the figure already shows.** A playback step moves its mark along the path drawn for that change, 320 ms ease-in-out: along the step arrow for a discrete jump (gradient descent jumps; it does not roll down the curve), along the belt for a conveyor. The arrow stays visible while the mark travels it, fades when the mark lands, and the next preview fades in. The chart scale never animates.
    - **Motion guardrails.** Animations here fail in the same few ways, so build them like this:
      - Take the start and end of a motion from the model *before* changing state, and end exactly on the model's new state. Never compute the target after mutating (reading `current()` after a push gives the step after next).
      - One animation owner per value: a single `requestAnimationFrame` loop holds the drawn state. A new input cancels or retargets the running motion; a spring and a tween must never both drive the same value.
      - Integrate with the real frame time, clamped (`dt = min(now − last, 1/30 s)`), so motion runs at the same speed at 60 and 120 Hz.
      - Playback timing is longer than the travel (a step every 700 ms, travel 320 ms), so a step never starts from a half-finished one.
      - Verify with numbers, not one screenshot: log the drawn position every frame through a full Run of at least 5 steps and through a fast slider drag. Each step's positions move monotonically from the old state to the new one, land exactly on it, and never jump backward.
    - **Every change of focus travels.** Moving the view or the selection from one thing to the next animates from wherever it is now, including from one selected item straight to another (not only from nothing to the first item). Camera target, distance and the popover all retarget the running motion; nothing snaps because a selection already existed. Focus changes use an ease-in-out tween of about 420 ms that starts from the current position and velocity zero; they never overshoot or bounce. Springs are only for values that follow a direct manipulation (dragging, sliding).
    - **Reduced motion.** With `prefers-reduced-motion`, values and marks jump, popovers only fade (≤ 80 ms), and idle animation stops.
    
    Use native buttons and inputs with visible labels, keyboard focus, and at least 44 px hit targets. Avoid capturing keys while someone is typing. Spatial dragging needs button or keyboard alternatives if changing the view is essential. Provide a meaningful accessible title/description and a text equivalent for visual state. Keep small-screen reading order aligned with the interaction order.
    
    ## Inspect and deliver
    
    Create or run no automated tests, snapshot checks, coverage jobs, or benchmark suites. Inspect the model and state transitions directly. When browser access is available, manually look at light/dark themes, the permitted controls, a narrow viewport, and reduced motion. Check a hint artifact's source for later answers as well as its visible surface. A blocked browser action is not permission to use a workaround; report the missing visual review honestly. Every screenshot you rely on is captured after the last edit to the file it shows, and every claim about it describes what is visible in it, not what the code should produce. When several files share chrome (an exploded view and its examples), build them from one source so a fix cannot land in one and miss the others.
    
    Deliver the file link with one short exploration prompt and return to the learner's explanation. Keep GIF capture separate until the owner approves the current HTML. When feedback changes a general design rule, update this reference or the shell as well as the example. Do not encode a particular scene's labels, equations, or learning steps into the reusable shell.
    
  • assets/exploded-view-kit.js92 KBc88bd6fdd16fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • assets/visualization-shell.html30 KB7b8dfc97da3dupstream ↗
    <!doctype html>
    <html lang="en">
    <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Socratic Workshop</title>
    <style>
    /* Glass tokens: text and lines are the text colour at fixed alpha tiers. */
    @property --p{syntax:'<percentage>';inherits:false;initial-value:0%}
    :root{
      color-scheme:light;
      --work:#ececec;
      --glass:rgba(250,250,250,.60);
      --edge:rgba(0,0,0,.12);
      --text-rgb:22,22,22;
      --field:rgba(0,0,0,.04);
      --field-edge:rgba(0,0,0,.10);
      --inset:rgba(0,0,0,.03);
      --sep-strong:rgba(0,0,0,.14);
      --sep-soft:rgba(0,0,0,.08);
      --t-strong:1;
      --t-value:.84;
      --t-body:.68;
      --t-label:.60;
      --t-hint:.56;
      --t-off:.31;
      --grid-line:rgba(var(--text-rgb),.07);
      --axis-line:rgba(var(--text-rgb),.20);
      --mark-neutral:rgba(var(--text-rgb),.74);
      --amber-lch:0.70 0.16 60;
      --coral-lch:0.62 0.18 35;
      --amber:oklch(var(--amber-lch));
      --coral:oklch(var(--coral-lch));
      --intro-a:oklch(0.55 0.15 60);
      --intro-b:oklch(0.52 0.17 35);
      --select-bg:linear-gradient(90deg in oklab,oklch(var(--amber-lch) / .15),oklch(var(--coral-lch) / .06));
      --select-edge:oklch(var(--amber-lch) / .30);
      --slider-fill:linear-gradient(90deg in oklab,rgba(var(--text-rgb),.16),rgba(var(--text-rgb),.05));
      --ember-fill:linear-gradient(90deg in oklab,var(--amber),var(--coral));
      --ground-bottom:oklch(0.905 0.035 68);
      /* Fine noise dither (~4%) over gradients wider than ~120 px so 8-bit bands never show. */
      --noise:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='128' height='128'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.9' numOctaves='2' stitchTiles='stitch'/%3E%3CfeColorMatrix type='saturate' values='0'/%3E%3C/filter%3E%3Crect width='128' height='128' filter='url(%23n)' opacity='0.04'/%3E%3C/svg%3E");
      --font:Inter,-apple-system,BlinkMacSystemFont,"Segoe UI",system-ui,sans-serif;
      --mono:"Geist Mono",ui-monospace,SFMono-Regular,monospace;
    }
    @media(prefers-color-scheme:dark){:root:not([data-theme="light"]){
      color-scheme:dark;
      --work:#1b1b1b;
      --glass:rgba(30,30,30,.50);
      --edge:rgba(255,255,255,.20);
      --text-rgb:255,255,255;
      --field:rgba(255,255,255,.05);
      --field-edge:rgba(255,255,255,.13);
      --inset:rgba(255,255,255,.03);
      --sep-strong:rgba(255,255,255,.20);
      --sep-soft:rgba(255,255,255,.10);
      --amber-lch:0.80 0.13 70;
      --coral-lch:0.70 0.15 35;
      --ground-bottom:oklch(0.285 0.040 55);
      --intro-a:var(--amber);
      --intro-b:var(--coral);
    }}
    :root[data-theme="dark"]{
      color-scheme:dark;
      --work:#1b1b1b;
      --glass:rgba(30,30,30,.50);
      --edge:rgba(255,255,255,.20);
      --text-rgb:255,255,255;
      --field:rgba(255,255,255,.05);
      --field-edge:rgba(255,255,255,.13);
      --inset:rgba(255,255,255,.03);
      --sep-strong:rgba(255,255,255,.20);
      --sep-soft:rgba(255,255,255,.10);
      --amber-lch:0.80 0.13 70;
      --coral-lch:0.70 0.15 35;
      --ground-bottom:oklch(0.285 0.040 55);
      --intro-a:var(--amber);
      --intro-b:var(--coral);
    }
    *{box-sizing:border-box}
    [hidden]{display:none!important}
    
    /* The body is the work: a neutral-to-ember floor under a fixed dot grid. */
    body{
      margin:0;
      min-height:100svh;
      display:grid;
      grid-template-columns:minmax(0,1fr) 392px;
      grid-template-rows:auto minmax(0,1fr);
      background:var(--work);
      color:rgba(var(--text-rgb),var(--t-body));
      font:17px/22px var(--font);
      isolation:isolate;
    }
    /* Fixed layers: ground gradient + dither, then dots in the same direction. A dot
       sits one OKLab L step (±0.05) off the ground behind it — lighter on dark
       ground, darker once ground L passes 0.55 — one contrast over the whole field. */
    body::before{content:"";position:fixed;inset:0;z-index:-1;pointer-events:none}
    body::before{background:var(--work)}
    
    
    
    
    
    /* Header floats on the work; only the theme pill is glass. */
    .stage-header{
      grid-column:1;grid-row:1;position:relative;
      padding:24px 32px 0 32px;
    }
    .stage-header h1{font-size:30px;line-height:36px;font-weight:600;letter-spacing:-.02em;color:rgba(var(--text-rgb),var(--t-strong));margin:0;text-wrap:balance}
    .stage-header .intro{margin:4px 0 0;width:fit-content;max-width:65ch;font-size:15px;line-height:20px;font-weight:500;background:linear-gradient(90deg in oklab,var(--intro-a),var(--intro-b));-webkit-background-clip:text;background-clip:text;color:transparent}
    .theme-toggle{
      position:absolute;top:20px;right:32px;
      display:inline-flex;align-items:center;gap:8px;
      min-height:44px;padding:0 16px;border-radius:10px;
      background:var(--field);border:1px solid var(--field-edge);
      color:rgba(var(--text-rgb),var(--t-value));font-size:15px;
    }
    .theme-toggle svg{width:18px;height:18px;flex:none}
    
    /* Right pillar: docked full-height chrome; panels become sections. */
    .pillar{
      grid-column:2;grid-row:1/3;
      width:392px;margin:0;
      display:flex;flex-direction:column;
      min-height:0;overflow-y:auto;
      background:var(--glass);
      -webkit-backdrop-filter:blur(6px);backdrop-filter:blur(6px);
      border-left:1px solid var(--edge);
    }
    .pillar>.panel{
      background:none;border:none;border-radius:0;
      padding:24px;min-width:0;
    }
    .pillar>.panel+.panel{border-top:1px solid var(--sep-strong)}
    .panel>h2,.panel-title{font-size:20px;line-height:25px;font-weight:600;color:rgba(var(--text-rgb),var(--t-strong));margin:0 0 16px}
    
    /* The figure lives in the free space; playback floats directly below it. */
    .figure-area{
      grid-column:1;grid-row:2;
      display:grid;grid-template-rows:minmax(0,1fr) auto auto;
      gap:12px;min-width:0;min-height:0;
      padding:32px 0 80px 32px;
    }
    .plot{position:relative;min-height:0}
    .graphic{display:block;width:100%;height:100%}
    .graphic text{font:15px var(--font);fill:rgba(var(--text-rgb),var(--t-hint))}
    .playback{
      position:fixed;left:0;right:392px;bottom:0;z-index:10;
      height:64px;padding:10px 32px;
      display:flex;align-items:center;gap:8px;white-space:nowrap;
      overflow-x:auto;scrollbar-width:none;
      background:var(--glass);
      -webkit-backdrop-filter:blur(6px);backdrop-filter:blur(6px);
      border:none;border-top:1px solid var(--edge);border-radius:0;
    }
    .playback::-webkit-scrollbar{display:none}
    .playback>button{flex:1 1 0;min-width:max-content;max-width:200px;height:44px;padding:0 16px;font-size:15px}
    .readouts{flex:none;margin-left:auto;align-self:stretch;display:flex;align-items:center;gap:32px;padding:0 0 0 24px;border-left:1px solid var(--sep-strong)}
    .readouts dl{margin:0;width:7ch;text-align:center}
    .readouts dt{font-size:15px;line-height:20px;color:rgba(var(--text-rgb),var(--t-label));margin-bottom:4px;text-align:center}
    .readouts dd{margin:0;font-size:17px;font-weight:400;line-height:22px;font-variant-numeric:tabular-nums;color:rgba(var(--text-rgb),var(--t-value));text-align:center}
    .figure-meta{display:flex;align-items:center;justify-content:center;gap:24px;flex-wrap:wrap}
    .legend{display:flex;gap:16px;flex-wrap:wrap;font-size:15px;line-height:20px;color:rgba(var(--text-rgb),var(--t-hint))}
    .legend i{flex:none;display:block}
    .legend .key-line{width:22px;height:0;border-top:2.5px solid var(--mark-neutral)}
    .legend .key-current{width:14px;height:14px;border-radius:50%;background:var(--amber);border:2px solid var(--work);box-sizing:border-box}
    .legend .key-next{width:20px;height:20px;border-radius:50%;border:2.5px solid var(--coral);box-sizing:border-box}
    .legend button{min-height:44px;padding:8px;border-radius:10px;background:none;border:none;border-radius:8px;color:inherit;font:inherit;font-size:15px;display:inline-flex;align-items:center;gap:8px;cursor:pointer}
    .playback-status{font-size:15px;line-height:20px;color:rgba(var(--text-rgb),var(--t-hint));margin:0;min-height:20px}
    
    /* Small glass pill for notices that sit over the figure. */
    .notice{
      position:absolute;top:12px;left:56px;right:16px;
      background:var(--glass);-webkit-backdrop-filter:blur(4px);backdrop-filter:blur(4px);
      border:1px solid var(--edge);border-radius:10px;padding:8px 12px;
      font-size:15px;line-height:20px;color:rgba(var(--text-rgb),var(--t-value));
    }
    
    /* Buttons: field look; primary/active is the selection look. */
    button,.button,select{
      position:relative;overflow:hidden;
      font:inherit;font-size:15px;
      min-height:44px;padding:0 16px;
      border:1px solid var(--field-edge);border-radius:10px;
      background-color:var(--field);background-image:linear-gradient(transparent,transparent);
      color:rgba(var(--text-rgb),var(--t-value));
      cursor:pointer;
    }
    button::after,.button::after{content:"";position:absolute;inset:0;border-radius:inherit;background:rgba(var(--text-rgb),0);transition:background .12s;pointer-events:none}
    button.primary,.button.primary{background-color:transparent;background-image:var(--select-bg);border-color:var(--select-edge);color:rgba(var(--text-rgb),var(--t-strong))}
    button:disabled{color:rgba(var(--text-rgb),var(--t-off));cursor:default}
    @media(hover:hover) and (pointer:fine){
      button:hover:not(:disabled)::after{background:rgba(var(--text-rgb),.05)}
      .legend button:hover{background:rgba(var(--text-rgb),.05)}
    }
    button:active:not(:disabled)::after{background:rgba(var(--text-rgb),.08)}
    button:focus-visible,.button:focus-visible,input:focus-visible,select:focus-visible,summary:focus-visible,a:focus-visible{outline:2px solid var(--amber);outline-offset:3px}
    
    /* Control block: label row, 8, 44 px control, 24 to the next label. */
    .control{margin-bottom:24px}
    .control>label{display:flex;align-items:baseline;justify-content:space-between;gap:12px;font-size:17px;color:rgba(var(--text-rgb),var(--t-label));margin-bottom:8px}
    .control output{font-size:17px;font-variant-numeric:tabular-nums;color:rgba(var(--text-rgb),var(--t-value))}
    
    /* Glass slider field: the fill carries the value, the amber thumb marks its edge.
       --p is a registered property so the fill and the drawn thumb glide together. */
    input[type="range"]{
      -webkit-appearance:none;appearance:none;
      display:block;width:100%;height:44px;margin:0;overflow:hidden;
      --p:0%;
      background:
        var(--noise) 0 0/128px 128px,
        linear-gradient(90deg,transparent calc(var(--p) - 1.5px),var(--amber) 0 calc(var(--p) + 1.5px),transparent 0) 0 4px/100% calc(100% - 8px) no-repeat,
        var(--slider-fill) 0 0/var(--p) 100% no-repeat,
        var(--field);
      border:1px solid var(--field-edge);border-radius:10px;
      cursor:pointer;
      transition:--p 120ms cubic-bezier(0.2,0.8,0.2,1);
    }
    input[type="range"]::-webkit-slider-runnable-track{height:44px;background:transparent;border:none}
    input[type="range"]::-webkit-slider-thumb{-webkit-appearance:none;width:3px;height:36px;margin-top:4px;border:none;background:transparent}
    input[type="range"]::-moz-range-track{height:100%;background:var(--field);border:none;border-radius:10px}
    input[type="range"]::-moz-range-progress{height:100%;background:var(--slider-fill);border-radius:10px 0 0 10px}
    input[type="range"]::-moz-range-thumb{width:3px;height:36px;border:none;border-radius:2px;background:var(--amber)}
    
    /* Feedback: an inset group with an amber leading bar, never a coloured fill. */
    .feedback{background:var(--inset);border-left:2px solid var(--amber);border-radius:8px;padding:16px}
    .feedback h2,.feedback h3{font-size:17px;line-height:22px;font-weight:600;color:rgba(var(--text-rgb),var(--t-strong));margin:0 0 6px}
    .feedback p{margin:0 0 8px;font-size:17px;line-height:22px;color:rgba(var(--text-rgb),var(--t-body))}
    .feedback p:last-child{margin-bottom:0}
    .feedback .detail{font-size:15px;line-height:20px;color:rgba(var(--text-rgb),var(--t-hint))}
    .equation{font-family:var(--mono);font-size:15px;overflow-wrap:anywhere}
    
    /* Disclosures: a soft separator, a 52 px row with a centred chevron; the body
       opens by animating its row height. */
    .disclosure{border-top:1px solid var(--sep-soft)}
    .panel *:not(.disclosure):has(+ .disclosure){margin-bottom:16px}
    /* Row = separator + 52 px; the hover fill is inset 4 px from the separators
       (44 px tall) and bleeds 8 px into the panel padding on both sides. */
    .disclosure summary{
      position:relative;
      list-style:none;display:flex;align-items:center;height:52px;margin:0 -8px;padding:0 8px;
      font-size:17px;color:rgba(var(--text-rgb),var(--t-body));cursor:pointer;
    }
    .disclosure summary::before{
      content:"";position:absolute;top:4px;bottom:4px;left:0;right:0;z-index:-1;
      border-radius:10px;background:rgba(var(--text-rgb),0);transition:background .12s;
    }
    .disclosure summary::-webkit-details-marker{display:none}
    /* Chevron is a centred 16 px box on the row's own centre line. */
    .disclosure summary::after{
      content:"";margin-left:auto;width:16px;height:16px;flex:none;
      display:inline-flex;align-items:center;justify-content:center;
    }
    .disclosure summary::after{
      background:none;
    }
    .disclosure summary::after{
      content:"";
      border-right:1.5px solid rgba(var(--text-rgb),var(--t-hint));
      border-bottom:1.5px solid rgba(var(--text-rgb),var(--t-hint));
      width:8px;height:8px;
      transform:rotate(45deg) translateY(-2px);
      transition:transform .2s;
    }
    .disclosure[open] summary::after{transform:rotate(225deg) translateY(-2px)}
    @media(hover:hover) and (pointer:fine){
      .disclosure summary:hover::before{background:rgba(var(--text-rgb),.05)}
      .disclosure summary:hover::after{border-color:rgba(var(--text-rgb),var(--t-value))}
    }
    .disclosure summary:active::before{background:rgba(var(--text-rgb),.08)}
    .disclosure .summary-label{display:flex;align-items:center}
    @supports (text-box: trim-both cap alphabetic){
      .disclosure .summary-label{text-box:trim-both cap alphabetic}
    }
    @supports not (text-box: trim-both cap alphabetic){
      .disclosure .summary-label{padding-top:1px}
    }
    .disclosure .disclosure-body{display:grid;grid-template-rows:0fr;transition:grid-template-rows .2s ease-in-out}
    .disclosure[open] .disclosure-body{grid-template-rows:1fr}
    .disclosure.closing .disclosure-body{grid-template-rows:0fr}
    .disclosure-inner{overflow:hidden;min-height:0}
    .disclosure-inner>:first-child{margin-top:8px}
    .disclosure-inner>:last-child{margin-bottom:16px}
    .disclosure p{font-size:17px;line-height:22px;color:rgba(var(--text-rgb),var(--t-body))}
    
    a{color:rgba(var(--text-rgb),var(--t-hint));text-underline-offset:4px}
    @media(hover:hover) and (pointer:fine){a:hover{color:rgba(var(--text-rgb),var(--t-value))}}
    
    /* Mark popovers: every meaningful mark is a button that opens one glass popover. */
    [data-mark]{cursor:pointer;transition:filter .12s}
    [data-mark]:hover{filter:brightness(1.25)}
    [data-mark].is-open:hover{filter:drop-shadow(0 0 1px var(--amber))}
    [data-mark]:focus-visible{outline:2px solid var(--amber);outline-offset:3px}
    [data-mark].is-open{filter:drop-shadow(0 0 1px var(--amber))}
    .mark-hit{fill:transparent;stroke:transparent;stroke-width:44px}
    .mark-popover{
      position:fixed;z-index:20;box-sizing:border-box;margin:0;
      max-width:260px;padding:12px;
      background:var(--glass);-webkit-backdrop-filter:blur(4px);backdrop-filter:blur(4px);
      border:1px solid var(--edge);border-radius:10px;
      opacity:0;transition:opacity .12s ease-in,transform .12s ease-in;
    }
    .mark-popover[data-side="right"]{transform:translateX(-4px) scale(.96);transform-origin:left center}
    .mark-popover[data-side="left"]{transform:translateX(4px) scale(.96);transform-origin:right center}
    .mark-popover.is-open{opacity:1;transform:translateX(0) scale(1);transition:opacity .16s cubic-bezier(.2,.8,.2,1),transform .16s cubic-bezier(.2,.8,.2,1)}
    .mark-popover h3{margin:0 0 4px;font-size:17px;line-height:22px;font-weight:600;color:rgba(var(--text-rgb),var(--t-strong))}
    .mark-popover p{margin:0;font-size:15px;line-height:20px;color:rgba(var(--text-rgb),var(--t-body))}
    .mark-popover .mark-value{margin-top:6px;font-variant-numeric:tabular-nums;color:rgba(var(--text-rgb),var(--t-value))}
    
    /* Comparison pattern: label, mark and value share one row and one scale. */
    .comparison{--comparison-columns:88px minmax(0,1fr) 72px;--comparison-gap:20px;--comparison-grid:25%;--guide:0%;margin-top:16px}
    .comparison-axis,.comparison-row{display:grid;grid-template-columns:var(--comparison-columns);column-gap:var(--comparison-gap);align-items:center}
    .comparison-axis{min-height:38px;padding-bottom:12px;font-size:15px;color:rgba(var(--text-rgb),var(--t-hint))}
    .comparison-scale{position:relative;height:22px;font-variant-numeric:tabular-nums}
    .comparison-tick{position:absolute;left:var(--tick);transform:translateX(-50%)}
    .comparison-tick:first-child{transform:none}.comparison-tick:last-child{transform:translateX(-100%)}
    .comparison-unit,.comparison-value{text-align:right;font-variant-numeric:tabular-nums}
    .comparison-label{display:flex;align-items:center;flex-wrap:wrap;gap:6px;padding:12px 0;font-size:17px;color:rgba(var(--text-rgb),var(--t-body))}
    .comparison-value{font-size:17px;color:rgba(var(--text-rgb),var(--t-value))}
    .comparison-track{position:relative;align-self:stretch;min-height:44px;display:flex;align-items:center;background:linear-gradient(to right,var(--grid-line) 1px,transparent 1px);background-size:var(--comparison-grid) 100%;border-right:1px solid var(--sep-soft)}
    .comparison-bar{height:15px;width:var(--value-percent,0%);background:rgba(var(--text-rgb),.20);border-radius:2px;transition:width .16s cubic-bezier(.2,.8,.2,1)}
    .comparison-bar.is-limiting{background:var(--ember-fill)}
    .comparison-guide{position:absolute;inset-block:0;left:var(--guide);border-left:2px dashed var(--coral);pointer-events:none}
    .comparison-badge{font-size:15px;padding:2px 6px;border-radius:8px;background:var(--select-bg);border:1px solid var(--select-edge);color:rgba(var(--text-rgb),var(--t-strong))}
    
    /* Annotated items: metadata sits in normal flow above the tile. */
    .annotated-set{display:flex;flex-wrap:wrap;align-items:flex-end;justify-content:center;gap:8px;list-style:none;margin:0;padding:0;min-width:0}
    .annotated-item{display:grid;grid-template-rows:minmax(20px,auto) auto;gap:8px;flex:0 0 auto;min-width:0;max-width:100%}
    .item-role{display:block;min-height:20px;text-align:center;font-size:15px;line-height:1.4;color:rgba(var(--text-rgb),var(--t-hint))}
    .item-body{display:flex;align-items:center;justify-content:center;min-height:44px;padding:10px 12px;border:1px solid transparent;border-radius:8px;background:var(--field);font-size:20px;line-height:1.25;letter-spacing:-.01em;white-space:nowrap;color:rgba(var(--text-rgb),var(--t-value))}
    .annotated-item.is-accented .item-body{background:var(--select-bg);border-color:var(--select-edge);color:rgba(var(--text-rgb),var(--t-strong));font-weight:600}
    .annotated-item.is-outlined .item-body{background:transparent;border-color:var(--coral);color:rgba(var(--text-rgb),var(--t-strong))}
    .annotated-item.is-empty .item-body{min-width:44px;border-style:dashed;border-color:var(--sep-strong);background:transparent;color:rgba(var(--text-rgb),var(--t-hint))}
    
    /* Reference/task pattern: one glass panel, two panes over a soft separator. */
    .learning-layout{display:grid;grid-template-columns:minmax(0,.85fr) minmax(0,1.45fr);gap:28px;align-items:stretch}
    .learning-layout h2{text-align:center}
    .reference-panel{display:grid;grid-template-rows:auto minmax(0,1fr);gap:16px;min-width:0}
    .panel-content{display:grid;place-content:center;min-width:0;padding-block:16px}
    .context-row{display:flex;align-items:center;justify-content:center;flex-wrap:wrap;gap:16px}
    .target-panel{min-width:0;padding-left:24px;border-left:1px solid var(--sep-soft)}
    .task-prompt{margin-top:16px}
    .actions{display:flex;align-items:center;justify-content:center;gap:12px;flex-wrap:wrap;margin-top:12px}
    
    /* Narrow: the stage scrolls; panels become full-width cards below the figure. */
    @media(max-width:900px){
      body{grid-template-columns:minmax(0,1fr);grid-template-rows:auto auto auto}
      .stage-header{grid-row:1;padding:16px 16px 8px}
      .figure-area{grid-row:2;padding:8px 16px 4px}
      .graphic{height:300px}
      .pillar{grid-column:1;grid-row:3;width:auto;margin:0;border-left:none;border-top:1px solid var(--sep-strong);overflow:visible;padding-bottom:64px}
      .pillar>.panel{border-radius:0}
      .playback{right:0}
      .learning-layout{grid-template-columns:1fr;gap:24px}
      .learning-layout .reference-panel{gap:16px;padding-bottom:24px;border-bottom:1px solid var(--sep-soft)}
      .target-panel{padding-left:0;border-left:0}
    }
    @media(max-width:600px){.comparison{--comparison-columns:52px minmax(0,1fr) 56px;--comparison-gap:12px}}
    
    @media(prefers-reduced-motion:reduce){
      *,*::before,*::after{animation:none!important;scroll-behavior:auto!important}
      input[type="range"],button::after,.mark-popover{transition-duration:80ms}
      .mark-popover{transform:none!important}
      .comparison-bar,.disclosure .disclosure-body{transition:none!important}
    }
    @media(prefers-reduced-transparency:reduce){
      :root{--glass:rgb(248,248,248)}
      @media(prefers-color-scheme:dark){:root:not([data-theme="light"]){--glass:rgb(30,30,30)}}
      :root[data-theme="dark"]{--glass:rgb(30,30,30)}
      *{-webkit-backdrop-filter:none!important;backdrop-filter:none!important}
    }
    @media(prefers-contrast:more){
      :root{--t-label:.80;--t-hint:.80;--edge:rgba(0,0,0,.40)}
      @media(prefers-color-scheme:dark){:root:not([data-theme="light"]){--edge:rgba(255,255,255,.40)}}
      :root[data-theme="dark"]{--edge:rgba(255,255,255,.40)}
    }
    @media print{
      :root,:root[data-theme="dark"]{color-scheme:light;--work:#fff;--glass:#fff;--edge:#ddd;--text-rgb:22,22,22;--field:#f5f5f5;--field-edge:#ddd;--inset:#f7f7f7;--sep-strong:#bbb;--sep-soft:#ddd}
      *{-webkit-backdrop-filter:none!important;backdrop-filter:none!important}
      body{display:block;background:#fff}
      body::before{display:none!important}
      .theme-toggle,.playback,input,select,.prediction{display:none}
      .stage-header,.figure-area{padding:0}
      .pillar{width:auto;margin:16px 0;overflow:visible}
      .panel{break-inside:avoid;margin-bottom:16px}
      .graphic{height:320px}
      .disclosure{display:block}
    }
    </style>
    
    <!-- Desktop height budget: keep the working scene and controls in one visible frame at 1280x720. -->
    
    </head>
    <body>
    
    <header class="stage-header">
    <div><h1>Explore a concept</h1><!-- Optional keyboard-legend slot: <p class="td-hint">Drag or ← → to turn · scroll or + − to descend · click a part</p> -->
    <p class="intro">Change one input to explore its effect.</p></div>
    <button id="theme-toggle" class="theme-toggle" aria-label="Switch color theme"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" aria-hidden="true"><circle cx="12" cy="12" r="4"/><path d="M12 2v2m0 16v2M2 12h2m16 0h2M5 5l1.5 1.5m11 11L19 19M5 19l1.5-1.5m11-11L19 5"/></svg><span id="theme-label">Dark</span></button>
    </header>
    <!-- Copy this shell into a standalone HTML. Replace the figure and panels with the concept's model, controls, and concise feedback. Keep only the classes used by that artifact. -->
    <main class="figure-area">
    <div class="plot"><svg class="graphic" role="img" aria-label="Demo figure"><path d="M40 300 L180 180 L320 220 L460 80" fill="none" stroke="var(--mark-neutral)" stroke-width="2.5"/><circle cx="320" cy="220" r="7" fill="var(--amber)" stroke="var(--work)" stroke-width="2"/><circle cx="460" cy="80" r="10" fill="none" stroke="var(--coral)" stroke-width="2.5"/></svg></div>
    <div class="playback"><button class="primary">Run</button><button>Step</button><button>Reset</button><div class="readouts"><dl><dt>Step</dt><dd>0</dd></dl><dl><dt>x</dt><dd>−2</dd></dl><dl><dt>Loss</dt><dd>25</dd></dl></div></div>
    </main>
    <aside class="pillar">
    <section class="panel"><h2>Shape the next step</h2><div class="control"><label for="demo-range">Input <output>0.25</output></label><input id="demo-range" type="range" min="0" max="1" step="0.05" value="0.25"></div><details class="disclosure"><summary><span class="summary-label">See the calculation</span></summary><div class="disclosure-body"><div class="disclosure-inner"><p class="equation">x next = x − η × f′(x)</p></div></div></details></section>
    <section class="panel"><div class="feedback"><h2>A smaller distance</h2><p>The next step moves closer to the minimum.</p></div><details class="disclosure"><summary><span class="summary-label">Model notes</span></summary><div class="disclosure-body"><div class="disclosure-inner"><p>Model assumptions go here.</p></div></div></details></section>
    </aside>
    <!-- Copy the needed inert pattern into the output, then fill its slots from the model. -->
    <template id="comparison-row-pattern"><div class="comparison-row"><span class="comparison-label" data-slot="label"></span><div class="comparison-track"><div class="comparison-bar" data-slot="bar"></div><i class="comparison-guide" aria-hidden="true"></i></div><span class="comparison-value" data-slot="value"></span></div></template>
    <template id="annotated-item-pattern"><li class="annotated-item"><span class="item-role" aria-hidden="true"></span><span class="item-body"></span></li></template>
    <template id="reference-task-pattern"><section class="panel learning-layout"><div class="reference-panel"><h2 data-slot="reference-title"></h2><div class="panel-content" data-slot="reference"></div></div><div class="target-panel"><h2 data-slot="task-title"></h2><div class="context-row" data-slot="context"></div><div class="task-prompt" data-slot="question"></div><div class="actions" data-slot="actions"></div></div></section></template>
    <script>
    const themeButton = document.getElementById('theme-toggle');
    const systemTheme = matchMedia('(prefers-color-scheme: dark)');
    function currentTheme(){return document.documentElement.dataset.theme || (systemTheme.matches ? 'dark' : 'light');}
    function updateThemeButton(){const dark = currentTheme() === 'dark';document.getElementById('theme-label').textContent = dark ? 'Light' : 'Dark';themeButton.setAttribute('aria-label',dark ? 'Switch to light theme' : 'Switch to dark theme');}
    try{const savedTheme = localStorage.getItem('socratic-workshop-theme');if(savedTheme === 'dark' || savedTheme === 'light')document.documentElement.dataset.theme = savedTheme;}catch{}
    themeButton.addEventListener('click',()=>{const theme = currentTheme() === 'dark' ? 'light' : 'dark';document.documentElement.dataset.theme = theme;try{localStorage.setItem('socratic-workshop-theme',theme);}catch{}updateThemeButton();});
    systemTheme.addEventListener('change',updateThemeButton);
    updateThemeButton();
    
    /* Slider fields fill to --p. The scene script may call syncRangeFill on reset. */
    function syncRangeFill(input){const min=Number(input.min||0),max=Number(input.max||100);input.style.setProperty('--p',(Number(input.value)-min)/(max-min)*100+'%');}
    document.querySelectorAll('input[type="range"]').forEach(input=>{syncRangeFill(input);input.addEventListener('input',()=>syncRangeFill(input));});
    
    /* Disclosures animate their row height; a closing detail keeps its body visible
       for 200 ms before the open attribute is removed. */
    document.querySelectorAll('.disclosure > summary').forEach(summary=>{
      summary.addEventListener('click',event=>{
        const d=summary.parentElement;
        if(d.open){event.preventDefault();d.classList.add('closing');setTimeout(()=>{d.open=false;d.classList.remove('closing');},200);}
      });
    });
    
    /* Mark popovers: a focusable mark (data-mark, or any element passed to bindMark)
       opens one glass popover beside it. Content is {title, body, value} or a
       function returning it; value may itself be a function for live numbers. */
    const markPopover=document.createElement('div');
    markPopover.className='mark-popover';
    markPopover.setAttribute('role','dialog');
    markPopover.hidden=true;
    document.body.appendChild(markPopover);
    let markAnchor=null,markBounds=null,markValueEl=null,markValueFn=null,popTimer=0;
    function openMarkPopover(anchor,content,bounds){
      closeMarkPopover();
      clearTimeout(popTimer);
      markAnchor=anchor;
      markBounds=bounds||null;
      anchor.classList.add('is-open');
      const data=typeof content==='function'?content():content;
      markPopover.replaceChildren();
      if(data.title){const h=document.createElement('h3');h.textContent=data.title;markPopover.append(h);}
      if(data.body){const p=document.createElement('p');p.textContent=data.body;markPopover.append(p);}
      markValueEl=null;markValueFn=null;
      if(data.value!=null){markValueEl=document.createElement('p');markValueEl.className='mark-value';markPopover.append(markValueEl);
        if(typeof data.value==='function'){markValueFn=data.value;markValueEl.textContent=markValueFn();}
        else markValueEl.textContent=data.value;}
      markPopover.hidden=false;
      markPopover.classList.remove('is-open');
      positionMarkPopover();
      requestAnimationFrame(()=>markPopover.classList.add('is-open'));
    }
    function positionMarkPopover(){
      if(!markAnchor)return;
      const r=markAnchor.getBoundingClientRect();
      const b=markBounds?markBounds.getBoundingClientRect():{left:8,top:8,right:innerWidth-8,bottom:innerHeight-8};
      const pw=markPopover.offsetWidth,ph=markPopover.offsetHeight;
      let side='right';
      let left=r.right+14;
      if(left+pw>b.right-8){left=r.left-14-pw;side='left';}
      left=Math.max(b.left+8,Math.min(left,b.right-8-pw));
      const top=Math.max(b.top+8,Math.min(r.top+r.height/2-ph/2,b.bottom-8-ph));
      markPopover.dataset.side=side;
      markPopover.style.left=left+'px';
      markPopover.style.top=top+'px';
    }
    function closeMarkPopover(){
      if(!markAnchor)return;
      markAnchor.classList.remove('is-open');
      markAnchor=null;markValueFn=null;markValueEl=null;
      markPopover.classList.remove('is-open');
      clearTimeout(popTimer);
      popTimer=setTimeout(()=>{markPopover.hidden=true;},130);
    }
    function toggleMarkPopover(anchor,content,bounds){
      if(markAnchor===anchor)closeMarkPopover();
      else openMarkPopover(anchor,content,bounds);
    }
    /* Re-read the live value and re-anchor while open (e.g. during playback). */
    function refreshMarkPopover(){
      if(markValueFn&&markValueEl)markValueEl.textContent=markValueFn();
      positionMarkPopover();
    }
    function bindMark(el,content,bounds){
      el.addEventListener('click',event=>{event.stopPropagation();toggleMarkPopover(el,content,bounds||el);});
      el.addEventListener('keydown',event=>{
        if(event.key==='Enter'||event.key===' '){event.preventDefault();toggleMarkPopover(el,content,bounds||el);}
      });
    }
    document.addEventListener('click',event=>{
      if(markAnchor&&!markPopover.contains(event.target)&&!markAnchor.contains(event.target))closeMarkPopover();
    });
    document.addEventListener('keydown',event=>{
      if(event.key==='Escape'&&markAnchor){const m=markAnchor;closeMarkPopover();if(m.focus)m.focus();}
    });
    </script>
    </body>
    </html>
    
  • .github/FUNDING.yml815 B7771442f3c2fupstream ↗
    # These are supported funding model platforms
    
    github:
    patreon: # Replace with a single Patreon username
    open_collective: # Replace with a single Open Collective username
    ko_fi: katanalabs
    tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
    community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
    liberapay: # Replace with a single Liberapay username
    issuehunt: # Replace with a single IssueHunt username
    lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
    polar: # Replace with a single Polar username
    buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
    thanks_dev: # Replace with a single thanks.dev username
    custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
    
  • .gitignore62 B8bff779d1543upstream ↗
    .DS_Store
    .env
    .env.*
    !.env.example
    learning/
    recordings/raw/
    
  • agents/openai.yaml260 Bc02d443df6d6upstream ↗
    interface:
      display_name: "Socratic Workshop"
      short_description: "Learn by explaining, with one hint at a time"
      default_prompt: "Use $socratic-workshop to help me understand a topic by explaining it myself, with one question or requested hint at a time."
    
  • examples/bottleneck.html40 KB7cc22344aa0fupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • examples/flashlight.html106 KB5714c1c651fdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • examples/gradient-descent.html41 KB902d8afdf3e2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • examples/keyboard-switch.html107 KB04d2e380cf63upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • examples/limo-door.html109 KB7865284ba468upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • examples/macbook-pro.html110 KBbfd77e44e530upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • examples/spanish-word-order.html31 KBd4277f3c41faupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • examples/studio-display-xdr.html108 KBd5a67d0028b9upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • LICENSE1.0 KB29a0b0da933eupstream ↗
    MIT License
    
    Copyright (c) 2026 smashburger-dev
    
    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:
    
    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.
    
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.
    
  • media/bottleneck.gif1.2 MB358dc6cfac83upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • media/gradient-descent.gif330 KB6518a1f4ba2aupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • media/keyboard-switch.gif1.1 MBa24168b71acfupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • media/learning-loop.gif161 KB03c82e026803upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • media/learning-loop.jpg96 KB453ae2663c75upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • media/macbook-pro.gif4.9 MBf4a9ec614342upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • media/spanish-word-order.gif108 KB186393818e0bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/smashburger-dev-socratic-workshop.md

// REPO STATS

24 stars
0 open issues
Last commit: 18d ago