How Leonxlnx/taste-skill's Three-Dial System Controls AI Generation

Leonxlnx/taste-skill translates three intuitive controls—DESIGN_VARIANCE, MOTION_INTENSITY, and VISUAL_DENSITY—into concrete AI parameters including language model temperature, animation frame counts, and diffusion sampling steps.

The Leonxlnx/taste-skill repository provides an open-source interface for steering generative AI outputs without manual prompt engineering. Its three-dial system encapsulates complex model hyperparameters into accessible sliders that control creative breadth, motion dynamics, and visual complexity.

Overview of the Three-Dial Architecture

The three-dial interface abstracts technical AI configurations into user-friendly controls. Each dial maps to specific generation characteristics across the pipeline.

DESIGN_VARIANCE

DESIGN_VARIANCE controls the breadth of creative exploration, determining how far the model may deviate from literal prompt interpretations. According to the source specification in skills/taste-skill/SKILL.md, this dial maps directly to the language model's temperature parameter.

The implementation applies a linear transformation:

temp = designVariance * 1.2

Valid ranges span from 0.0 (deterministic, literal output) to 1.0 (maximum creativity and randomness). Higher values increase the probability of bold, unexpected design choices.

MOTION_INTENSITY

MOTION_INTENSITY governs the dynamism of generated motion assets, including animation length, speed, and transition smoothness. As implemented in skill.sh, this value translates into interpolation frame counts.

The calculation follows:

frames = 5 + motionIntensity * 3

The dial accepts values from 0 (static images, no motion) to 10 (high-energy, extended animations). Larger values produce smoother transitions and longer motion sequences.

VISUAL_DENSITY

VISUAL_DENSITY regulates the amount of detail packed into each frame, controlling color richness, pattern complexity, and element count. This dial adjusts both the sampling steps and guidance scale of the underlying diffusion model.

The mapping uses two equations:

steps = 20 + visualDensity * 10
guidance = 7 + visualDensity

Operating between 0 (minimalist, sparse compositions) and 5 (highly intricate, densely packed visuals), this parameter directly impacts rendering time and computational load.

Technical Implementation

The dial system bridges user interface inputs and backend generation requests through a structured payload format.

Parameter Mapping Pipeline

When a user invokes the skill, the three values are collected into a JSON payload that the backend parses to construct the generation request:

{
  "prompt": "a futuristic café interior",
  "designVariance": 0.7,
  "motionIntensity": 4,
  "visualDensity": 3
}

The skill.sh entry-point script handles the translation logic, converting these normalized values into model-specific hyperparameters before submitting to the rendering pipeline.

Source Code Architecture

Key files define and implement the three-dial behavior:

• skills/taste-skill/SKILL.md – Contains the high-level specification and UI layout definitions for the dial interface
• skill.sh – The entry-point script that parses dial values from environment variables or command-line arguments and assembles the generation request
• skills/taste-skill-v1/SKILL.md – Historical version showing the evolution of dial definitions and parameter ranges

Usage Examples

The three-dial system supports both command-line invocation and programmatic API access.

Command Line Interface

Set the dials via environment variables and invoke the skill wrapper:

# Configure the three dials

DESIGNVARIANCE=0.8   # More adventurous designs

MOTIONINTENSITY=5    # Medium-fast animation

VISUALDENSITY=2      # Moderately detailed visuals

# Execute generation

./skill.sh \
  --prompt "a cyber-punk street market at night" \
  --design-variance "$DESIGNVARIANCE" \
  --motion-intensity "$MOTIONINTENSITY" \
  --visual-density "$VISUALDENSITY"

Programmatic API Integration

For web front-ends or automated pipelines, send dial values directly in the request body:

fetch('https://api.taste-skill.dev/generate', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    prompt: 'a whimsical garden of floating lanterns',
    designVariance: 0.5,
    motionIntensity: 2,
    visualDensity: 4
  })
})
.then(r => r.json())
.then(data => {
  console.log('Generated asset:', data.assetUrl);
});

Summary

• DESIGN_VARIANCE maps to language model temperature (temp = designVariance * 1.2), controlling creative randomness from 0.0 to 1.0
• MOTION_INTENSITY determines animation frame counts (frames = 5 + motionIntensity * 3), ranging from static (0) to high-energy motion (10)
• VISUAL_DENSITY adjusts diffusion sampling steps and guidance scale (steps = 20 + visualDensity * 10, guidance = 7 + visualDensity), spanning minimalist (0) to highly detailed (5)
• The implementation resides primarily in skill.sh and skills/taste-skill/SKILL.md, accepting both CLI arguments and JSON API payloads

Frequently Asked Questions

What is the valid range for each dial in Leonxlnx/taste-skill?

DESIGN_VARIANCE accepts values from 0.0 to 1.0, MOTION_INTENSITY ranges from 0 to 10, and VISUAL_DENSITY operates between 0 and 5. Exceeding these ranges may result in clamped values or generation errors depending on the specific version of skill.sh being used.

How does DESIGN_VARIANCE differ from VISUAL_DENSITY?

DESIGN_VARIANCE influences the language model's creativity and willingness to deviate from the prompt, mapped to the temperature parameter. VISUAL_DENSITY controls the rendering quality and detail level of the final image through diffusion sampling steps and guidance scale, affecting visual complexity rather than conceptual interpretation.

Where is the three-dial logic implemented in the codebase?

The dial definitions and UI specifications reside in skills/taste-skill/SKILL.md, while the actual parameter mapping and request assembly logic is implemented in the skill.sh entry-point script. Historical dial definitions can be found in skills/taste-skill-v1/SKILL.md for version comparison.

Can I use the three-dial system programmatically without the command line?

Yes, the system accepts JSON payloads via HTTP POST requests to the generation endpoint. Include designVariance, motionIntensity, and visualDensity as numeric fields in the request body alongside your prompt string, as demonstrated in the JavaScript fetch example.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}