Generated banner for Playground
Generated logo for Playground

Playground

ClineOfficialPublished by Cline

  • 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 Cline

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 visually configure parameters, view live updates, and generate actionable natural-language prompts. By utilizing predefined templates for design, data, architecture, and review tasks, it helps bridge the gap between complex configuration spaces and AI-ready instructions. Each playground is designed to be self-contained with no external dependencies, ensuring reliability and ease of use.

What it does

  • Creates interactive HTML files with live visual previews
  • Provides configurable controls for complex input spaces
  • Generates natural-language prompts based on user selections
  • Includes copy-to-clipboard functionality for generated prompts
  • Supports multiple templates for design, data, and code review
  • Implements a reactive state management pattern for instant updates

When to use it

  • When you need a visual tool to explore complex configuration options
  • When you want to generate precise, context-aware prompts for an AI agent
  • When you need to build interactive explorers for data, design, or architecture
  • When you require a portable, single-file interface for collaborative review

Advantages

  • Self-contained design avoids external dependency issues
  • Immediate visual feedback loop improves configuration accuracy
  • Natural language prompt generation reduces manual drafting effort
  • Presets and sensible defaults ensure a usable starting point

Usage examples

“Create a design playground for a card component.”
An HTML file is generated with controls for border-radius, shadow, and padding, allowing you to visually tune the card and copy the resulting prompt for an AI to implement the design.
“Build a data explorer for my SQL query parameters.”
An interactive tool is created that lets you toggle filters and join types, outputting a clean SQL query string based on your selections.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/cline/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 Cline

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 their agent.

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 when available. After writing the HTML file, launch it in the user's default browser if the environment supports that; otherwise provide the file path.

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/document-critique.md

Document Critique Template

Use this template when the playground helps review and critique documents: SKILL.md files, READMEs, specs, proposals, or any text that needs structured feedback with approve/reject/comment workflow.

Layout

+---------------------------+--------------------+
|                           |                    |
|  Document content         |  Suggestions panel |
|  with line numbers        |  (filterable list) |
|  and suggestion           |  • Approve         |
|  highlighting             |  • Reject          |
|                           |  • Comment         |
|                           |                    |
+---------------------------+--------------------+
|  Prompt output (approved + commented items)    |
|  [ Copy Prompt ]                               |
+------------------------------------------------+

Key components

Document panel (left)
  • Display full document with line numbers

  • Highlight lines with suggestions using a colored left border

  • Color-code by status: pending (amber), approved (green), rejected (red with opacity)

  • Click a suggestion card to scroll to the relevant line

Suggestions panel (right)
  • Filter tabs: All / Pending / Approved / Rejected

  • Stats in header showing counts for each status

  • Each suggestion card shows:

    • Line reference (e.g., "Line 3" or "Lines 17-24")

    • The suggestion text

    • Action buttons: Approve / Reject / Comment (or Reset if already decided)

    • Optional textarea for user comments

Prompt output (bottom)
  • Generates a prompt only from approved suggestions and user comments

  • Groups by: Approved Improvements, Additional Feedback, Rejected (for context)

  • Copy button with "Copied!" feedback

State structure

const suggestions = [
  {
    id: 1,
    lineRef: "Line 3",
    targetText: "description: Creates interactive...",
    suggestion: "The description is too long. Consider shortening.",
    category: "clarity",  // clarity, completeness, performance, accessibility, ux
    status: "pending",    // pending, approved, rejected
    userComment: ""
  },
  // ... more suggestions
];

let state = {
  suggestions: [...],
  activeFilter: "all",
  activeSuggestionId: null
};

Suggestion matching to lines

Match suggestions to document lines by parsing the lineRef:

const suggestion = state.suggestions.find(s => {
  const match = s.lineRef.match(/Line[s]?\s*(\d+)/);
  if (match) {
    const targetLine = parseInt(match[1]);
    return Math.abs(targetLine - lineNum) <= 2; // fuzzy match nearby lines
  }
  return false;
});

Document rendering

Handle markdown-style formatting inline:

// Skip ``` lines, wrap content in code-block-wrapper
if (line.startsWith('```')) {
  inCodeBlock = !inCodeBlock;
  // Open or close wrapper div
}

// Headers
if (line.startsWith('# ')) renderedLine = `<h1>...</h1>`;
if (line.startsWith('## ')) renderedLine = `<h2>...</h2>`;

// Inline formatting (outside code blocks)
renderedLine = renderedLine.replace(/`([^`]+)`/g, '<code>$1</code>');
renderedLine = renderedLine.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');

Prompt output generation

Only include actionable items:

function updatePrompt() {
  const approved = state.suggestions.filter(s => s.status === 'approved');
  const withComments = state.suggestions.filter(s => s.userComment?.trim());

  if (approved.length === 0 && withComments.length === 0) {
    // Show placeholder
    return;
  }

  let prompt = 'Please update [DOCUMENT] with the following changes:\n\n';

  if (approved.length > 0) {
    prompt += '## Approved Improvements\n\n';
    for (const s of approved) {
      prompt += `**${s.lineRef}:** ${s.suggestion}`;
      if (s.userComment?.trim()) {
        prompt += `\n  → User note: ${s.userComment.trim()}`;
      }
      prompt += '\n\n';
    }
  }

  // Additional feedback from non-approved items with comments
  // Rejected items listed for context only
}

Styling highlights

.doc-line.has-suggestion {
  border-left: 3px solid #bf8700;  /* amber for pending */
  background: rgba(191, 135, 0, 0.08);
}

.doc-line.approved {
  border-left-color: #1a7f37;  /* green */
  background: rgba(26, 127, 55, 0.08);
}

.doc-line.rejected {
  border-left-color: #cf222e;  /* red */
  background: rgba(207, 34, 46, 0.08);
  opacity: 0.6;
}

Pre-populating suggestions

When building a critique playground for a specific document:

  1. Read the document content

  2. Analyze and generate suggestions with:

    • Specific line references

    • Clear, actionable suggestion text

    • Category tags (clarity, completeness, performance, accessibility, ux)

  3. Embed both the document content and suggestions array in the HTML

Example use cases

  • SKILL.md review (skill definition quality, completeness, clarity)

  • README critique (documentation quality, missing sections, unclear explanations)

  • Spec review (requirements clarity, missing edge cases, ambiguity)

  • Proposal feedback (structure, argumentation, missing context)

  • Code comment review (docstring quality, inline comment usefulness)

Requirements and compatibility

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
Cline
Publisher
Cline (Official)
Source
cline/skills · skills/playground · commit 2637846
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Cline.

Download ZIP

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