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

> Discover how Leonxlnx/taste-skill's three-dial system (DESIGN_VARIANCE, MOTION_INTENSITY, VISUAL_DENSITY) controls AI generation by translating intuitive controls into concrete AI parameters.

- Repository: [Leon Lin/taste-skill](https://github.com/Leonxlnx/taste-skill)
- Tags: deep-dive
- Published: 2026-05-30

---

**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`](https://github.com/Leonxlnx/taste-skill/blob/main/skills/taste-skill/SKILL.md), this dial maps directly to the language model's temperature parameter.

The implementation applies a linear transformation:

```python
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`](https://github.com/Leonxlnx/taste-skill/blob/main/skill.sh), this value translates into interpolation frame counts.

The calculation follows:

```python
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:

```python
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:

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

```

The [`skill.sh`](https://github.com/Leonxlnx/taste-skill/blob/main/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`](https://github.com/Leonxlnx/taste-skill/blob/main/skills/taste-skill/SKILL.md)** – Contains the high-level specification and UI layout definitions for the dial interface
- **[`skill.sh`](https://github.com/Leonxlnx/taste-skill/blob/main/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`](https://github.com/Leonxlnx/taste-skill/blob/main/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:

```bash

# 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:

```javascript
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`](https://github.com/Leonxlnx/taste-skill/blob/main/skill.sh) and [`skills/taste-skill/SKILL.md`](https://github.com/Leonxlnx/taste-skill/blob/main/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`](https://github.com/Leonxlnx/taste-skill/blob/main/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`](https://github.com/Leonxlnx/taste-skill/blob/main/skills/taste-skill/SKILL.md), while the actual parameter mapping and request assembly logic is implemented in the [`skill.sh`](https://github.com/Leonxlnx/taste-skill/blob/main/skill.sh) entry-point script. Historical dial definitions can be found in [`skills/taste-skill-v1/SKILL.md`](https://github.com/Leonxlnx/taste-skill/blob/main/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.