Generated banner for Playground
Generated logo for Playground

Playground

AnthropicOfficialPublished by Anthropic

  • Skill
  • Content generator
  • Software development
  • Apache-2.0
  • No issues found

From the author

Creates interactive HTML playgrounds — self-contained single-file explorers that let users configure something visually through controls, see a live preview, and copy out a prompt. Use when the user asks to make a playground, explorer, or interactive tool for a topic.
— the description by Anthropic

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

Playground is a tool for creating single-file HTML explorers that allow users to interact with complex configurations through a visual interface. It provides a structured way to build tools where users adjust settings via controls, view live updates, and generate natural-language prompts based on their selections. By using predefined templates, it ensures consistency in design, state management, and prompt output, making it ideal for topics that are difficult to describe through text alone.

What it does

  • Creates single-file HTML playgrounds with no external dependencies.
  • Provides a live preview that updates instantly as controls are adjusted.
  • Generates actionable, natural-language prompts based on user configuration.
  • Supports multiple templates for design, data, architecture, and document review.
  • Includes preset configurations for quick exploration.
  • Features a copy-to-clipboard function for generated prompts.

When to use it

  • When you need a visual tool to explore complex configuration spaces.
  • When a user needs to generate specific prompts based on visual or structural choices.
  • When you want to provide an interactive way to experiment with design, data, or architecture.
  • When you need to simplify complex inputs into a user-friendly interface.

Advantages

  • Self-contained files ensure portability and reliability without external dependencies.
  • Immediate visual feedback improves user understanding and decision-making.
  • Natural-language prompt generation bridges the gap between visual exploration and AI interaction.
  • Standardized templates ensure a consistent and professional user experience.

Usage examples

“Create a design playground for a card component.”
Generates an HTML file with controls for border-radius, shadows, and spacing, allowing the user to visually design a card and copy the resulting prompt.
“Build a data explorer for my SQL query builder.”
Produces an interactive tool that lets the user select table joins and filters, outputting a natural-language request to generate the corresponding SQL.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/anthropics/playground/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip playground.zip -d .agents/skills

Documentation by Anthropic

Playground Builder

A playground is a self-contained HTML file with interactive controls on one side, a live preview on the other, and a prompt output at the bottom with a copy button. The user adjusts controls, explores visually, then copies the generated prompt back into Claude.

When to use this skill

When the user asks for an interactive playground, explorer, or visual tool for a topic — especially when the input space is large, visual, or structural and hard to express as plain text.

How to use this skill

  1. Identify the playground type from the user's request

  2. Load the matching template from templates/:

    • templates/design-playground.md — Visual design decisions (components, layouts, spacing, color, typography)

    • templates/data-explorer.md — Data and query building (SQL, APIs, pipelines, regex)

    • templates/concept-map.md — Learning and exploration (concept maps, knowledge gaps, scope mapping)

    • templates/document-critique.md — Document review (suggestions with approve/reject/comment workflow)

    • templates/diff-review.md — Code review (git diffs, commits, PRs with line-by-line commenting)

    • templates/code-map.md — Codebase architecture (component relationships, data flow, layer diagrams)

  3. Follow the template to build the playground. If the topic doesn't fit any template cleanly, use the one closest and adapt.

  4. Open in browser. After writing the HTML file, run open <filename>.html to launch it in the user's default browser.

Core requirements (every playground)

  • Single HTML file. Inline all CSS and JS. No external dependencies.

  • Live preview. Updates instantly on every control change. No "Apply" button.

  • Prompt output. Natural language, not a value dump. Only mentions non-default choices. Includes enough context to act on without seeing the playground. Updates live.

  • Copy button. Clipboard copy with brief "Copied!" feedback.

  • Sensible defaults + presets. Looks good on first load. Include 3-5 named presets that snap all controls to a cohesive combination.

  • Dark theme. System font for UI, monospace for code/values. Minimal chrome.

State management pattern

Keep a single state object. Every control writes to it, every render reads from it.

const state = { /* all configurable values */ };

function updateAll() {
  renderPreview(); // update the visual
  updatePrompt();  // rebuild the prompt text
}
// Every control calls updateAll() on change

Prompt output pattern

function updatePrompt() {
  const parts = [];

  // Only mention non-default values
  if (state.borderRadius !== DEFAULTS.borderRadius) {
    parts.push(`border-radius of ${state.borderRadius}px`);
  }

  // Use qualitative language alongside numbers
  if (state.shadowBlur > 16) parts.push('a pronounced shadow');
  else if (state.shadowBlur > 0) parts.push('a subtle shadow');

  prompt.textContent = `Update the card to use ${parts.join(', ')}.`;
}

Common mistakes to avoid

  • Prompt output is just a value dump → write it as a natural instruction

  • Too many controls at once → group by concern, hide advanced in a collapsible section

  • Preview doesn't update instantly → every control change must trigger immediate re-render

  • No defaults or presets → starts empty or broken on load

  • External dependencies → if CDN is down, playground is dead

  • Prompt lacks context → include enough that it's actionable without the playground

Files

templates/diff-review.md

Diff Review Template

Use this template when the playground is about reviewing code diffs: git commits, pull requests, code changes with interactive line-by-line commenting for feedback.

Layout

+-------------------+----------------------------------+
|                   |                                  |
|  Commit Header:   |  Diff Content                    |
|  • Hash           |  (files with hunks)              |
|  • Message        |  with line numbers               |
|  • Author/Date    |  and +/- indicators              |
|                   |                                  |
+-------------------+----------------------------------+
|  Prompt Output Panel (fixed bottom-right)            |
|  [ Copy All ]                                        |
|  Shows all comments formatted for prompt             |
+------------------------------------------------------+

Diff review playgrounds display git diffs with syntax highlighting. Users click lines to add comments, which become part of the generated prompt for code review feedback.

Control types for diff review

FeatureControlBehavior
Line commentingClick any diff lineOpens textarea below the line
Comment indicatorBadge on commented linesShows which lines have feedback
Save/CancelButtons in comment boxPersist or discard comment
Copy promptButton in prompt panelCopies all comments to clipboard

Diff rendering

Parse diff data into structured format for rendering:

const diffData = [
  {
    file: "path/to/file.py",
    hunks: [
      {
        header: "@@ -41,13 +41,13 @@ function context",
        lines: [
          { type: "context", oldNum: 41, newNum: 41, content: "unchanged line" },
          { type: "deletion", oldNum: 42, newNum: null, content: "removed line" },
          { type: "addition", oldNum: null, newNum: 42, content: "added line" },
        ]
      }
    ]
  }
];

Line type styling

TypeBackgroundText ColorPrefix
contexttransparentdefault (space)
additiongreen tint (#dafbe1 light / rgba(46,160,67,0.15) dark)green (#1a7f37 light / #7ee787 dark)+
deletionred tint (#ffebe9 light / rgba(248,81,73,0.15) dark)red (#cf222e light / #f85149 dark)-
hunk-headerblue tint (#ddf4ff light)blue (#0969da light)@@

Comment system

Each diff line gets a unique identifier for comment tracking:

const comments = {}; // { lineId: commentText }

function selectLine(lineId, lineEl) {
  // Deselect previous
  document.querySelectorAll('.diff-line.selected').forEach(el =>
    el.classList.remove('selected'));
  document.querySelectorAll('.comment-box.active').forEach(el =>
    el.classList.remove('active'));

  // Select new
  lineEl.classList.add('selected');
  document.getElementById(`comment-box-${lineId}`).classList.add('active');
}

function saveComment(lineId) {
  const textarea = document.getElementById(`textarea-${lineId}`);
  const comment = textarea.value.trim();

  if (comment) {
    comments[lineId] = comment;
  } else {
    delete comments[lineId];
  }

  renderDiff(); // Re-render to show comment indicator
  updatePromptOutput();
}

Prompt output format

Generate a structured code review format:

function updatePromptOutput() {
  const commentKeys = Object.keys(comments);

  if (commentKeys.length === 0) {
    promptContent.innerHTML = '<span class="no-comments">Click on any line to add a comment...</span>';
    return;
  }

  let output = 'Code Review Comments:\n\n';

  commentKeys.forEach(lineId => {
    const lineEl = document.querySelector(`[data-line-id="${lineId}"]`);
    const file = lineEl.dataset.file;
    const lineNum = lineEl.dataset.lineNum;
    const content = lineEl.dataset.content;

    output += `📍 ${file}:${lineNum}\n`;
    output += `   Code: ${content.trim()}\n`;
    output += `   Comment: ${comments[lineId]}\n\n`;
  });

  promptContent.textContent = output;
}

Data attributes for line elements

Store metadata on each line element for prompt generation:

<div class="diff-line addition"
     data-line-id="0-1-5"
     data-file="src/utils/handler.py"
     data-line-num="45"
     data-content="subagent_id = tracker.register()">

Pre-populating with real data

To create a diff viewer for a specific commit:

  1. Run git show <commit> --format="%H%n%s%n%an%n%ad" -p

  2. Parse the output into the diffData structure

  3. Include commit metadata in the header section

Theme support

Support both light and dark modes:

/* Light mode */
body { background: #f6f8fa; color: #1f2328; }
.file-card { background: #ffffff; border: 1px solid #d0d7de; }
.diff-line.addition { background: #dafbe1; }
.diff-line.deletion { background: #ffebe9; }

/* Dark mode */
body { background: #0d1117; color: #c9d1d9; }
.file-card { background: #161b22; border: 1px solid #30363d; }
.diff-line.addition { background: rgba(46, 160, 67, 0.15); }
.diff-line.deletion { background: rgba(248, 81, 73, 0.15); }

Interactive features

  • Hover hint: Show "Click to comment" tooltip on line hover

  • Comment indicator: Badge (💬) on lines with saved comments

  • Toast notification: "Copied to clipboard!" feedback on copy

  • Edit existing: Allow editing previously saved comments

Example topics

  • Git commit review (single commit diff with line comments)

  • Pull request review (multiple commits, file-level and line-level comments)

  • Code diff comparison (before/after refactoring)

  • Merge conflict resolution (showing both versions with annotations)

  • Code audit (security review with findings per line)

Requirements and compatibility

Written for: Claude Code, Claude apps

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
Anthropic
Publisher
Anthropic (Official)
Source
anthropics/claude-plugins-official · plugins/playground/skills/playground · commit 0412be7
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from plugins/playground/LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Anthropic or Anthropic.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download playground.zip